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

private void resultsToTgtMorefMap(RetrieveResult results,
        Map<String, ManagedObjectReference> tgtMoref) {
    List<ObjectContent> oCont = (results != null) ? results.getObjects() : null;

    if (oCont != null) {
        for (ObjectContent oc : oCont) {
            ManagedObjectReference mr = oc.getObj();
            String entityNm = null;
            List<DynamicProperty> dps = oc.getPropSet();
            if (dps != null) {
                for (DynamicProperty dp : dps) {
                    entityNm = (String) dp.getVal();
                }
            }
            tgtMoref.put(entityNm, mr);
        }
    }
}

public Map<String, ManagedObjectReference> toMap(RetrieveResult rslts)
        throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg {
    final Map<String, ManagedObjectReference> tgtMoref = new HashMap<String, ManagedObjectReference>();
    String token = null;
    token = populate(rslts, tgtMoref);

    while (token != null && !token.isEmpty()) {
        // fetch results based on new token
        rslts = this.vimPort.continueRetrievePropertiesEx(
                this.serviceContent.getPropertyCollector(), token);

        token = populate(rslts, tgtMoref);
    }

    return tgtMoref;
}

public static String populate(final RetrieveResult rslts,
        final Map<String, ManagedObjectReference> tgtMoref) {
    String token = null;
    if (rslts != null) {
        token = rslts.getToken();
        for (ObjectContent oc : rslts.getObjects()) {
            ManagedObjectReference mr = oc.getObj();
            String entityNm = null;
            List<DynamicProperty> dps = oc.getPropSet();
            if (dps != null) {
                for (DynamicProperty dp : dps) {
                    entityNm = (String) dp.getVal();
                }
            }
            tgtMoref.put(entityNm, mr);
        }
    }
    return token;
}

private static String populate(final RetrieveResult results, final Map<String, ManagedObjectReference> tgtMoref) {
    String token = null;
    if (results != null) {
        token = results.getToken();
        for (ObjectContent oc : results.getObjects()) {
            ManagedObjectReference mr = oc.getObj();
            String entityNm = null;
            List<DynamicProperty> dps = oc.getPropSet();
            if (dps != null) {
                for (DynamicProperty dp : dps) {
                    entityNm = (String) dp.getVal();
                }
            }
            tgtMoref.put(entityNm, mr);
        }
    }

    return token;
}

/**
 * Uses the new RetrievePropertiesEx method to emulate the now deprecated
 * RetrieveProperties method
 *
 * @param filterSpecs
 * @return list of object content
 * @throws RuntimeFaultFaultMsg
 * @throws InvalidPropertyFaultMsg
 * @throws Exception
 */
private List<ObjectContent> retrievePropertiesAllObjects(
        List<PropertyFilterSpec> filterSpecs)
        throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg {

    RetrieveOptions retrieveOptions = new RetrieveOptions();
    ManagedObjectReference collector = serviceContent
            .getPropertyCollector();

    List<ObjectContent> contents = new ArrayList<ObjectContent>();

    RetrieveResult results = vimPort.retrievePropertiesEx(collector,
            filterSpecs, retrieveOptions);
    if (results != null && results.getObjects() != null
            && !results.getObjects().isEmpty()) {
        contents.addAll(results.getObjects());
    }
    String token = null;
    if (results != null && results.getToken() != null) {
        token = results.getToken();
    }
    while (token != null && token.length() > 0) {
        results = vimPort.continueRetrievePropertiesEx(collector, token);
        token = null;
        if (results != null) {
            token = results.getToken();
            if (results.getObjects() != null
                    && !results.getObjects().isEmpty()) {
                contents.addAll(results.getObjects());
            }
        }
    }

    return contents;
}

public RetrieveResult containerViewByType(
        final ManagedObjectReference container,
        final String morefType,
        final RetrieveOptions retrieveOptions
) throws RuntimeFaultFaultMsg, InvalidPropertyFaultMsg {
    return this.containerViewByType(container, morefType, retrieveOptions, "name");
}

/**
 * Returns the raw RetrieveResult object for the provided container filtered on properties list
 *
 * @param container       - container to look in
 * @param morefType       - type to filter for
 * @param morefProperties - properties to include
 * @return com.vmware.vim25.RetrieveResult for this query
 * @throws RuntimeFaultFaultMsg
 * @throws InvalidPropertyFaultMsg
 */
public RetrieveResult containerViewByType(
        final ManagedObjectReference container,
        final String morefType,
        final RetrieveOptions retrieveOptions,
        final String... morefProperties
) throws RuntimeFaultFaultMsg, InvalidPropertyFaultMsg {
    init();

    PropertyFilterSpec[] propertyFilterSpecs = propertyFilterSpecs(container, morefType,
            morefProperties);

    return containerViewByType(container, morefType, morefProperties, retrieveOptions,
            propertyFilterSpecs);
}

public RetrieveResult containerViewByType(
        final ManagedObjectReference container,
        final String morefType,
        final String[] morefProperties,
        final RetrieveOptions retrieveOptions,
        final PropertyFilterSpec... propertyFilterSpecs
) throws RuntimeFaultFaultMsg, InvalidPropertyFaultMsg {
    init();
    return this.vimPort.retrievePropertiesEx(
            this.serviceContent.getPropertyCollector(),
            Arrays.asList(propertyFilterSpecs),
            retrieveOptions
    );
}

/**
 * Returns all the MOREFs of the specified type that are present under the
 * folder
 *
 * @param folder    {@link ManagedObjectReference} of the folder to begin the search
 *                  from
 * @param morefType Type of the managed entity that needs to be searched
 * @return Map of name and MOREF of the managed objects present. If none
 *         exist then empty Map is returned
 * @throws InvalidPropertyFaultMsg
 *
 * @throws RuntimeFaultFaultMsg
 *
 */
public Map<String, ManagedObjectReference> inFolderByType(
        final ManagedObjectReference folder, final String morefType,
        final RetrieveOptions retrieveOptions
) throws RuntimeFaultFaultMsg, InvalidPropertyFaultMsg {
    final PropertyFilterSpec[] propertyFilterSpecs = propertyFilterSpecs(folder, morefType,
            "name");

    // reuse this property collector again later to scroll through results
    final ManagedObjectReference propertyCollector = this.serviceContent.getPropertyCollector();

    RetrieveResult results = this.vimPort.retrievePropertiesEx(
            propertyCollector,
            Arrays.asList(propertyFilterSpecs),
            retrieveOptions);

    final Map<String, ManagedObjectReference> tgtMoref = new HashMap<>();
    while (results != null && !results.getObjects().isEmpty()) {
        resultsToTgtMorefMap(results, tgtMoref);
        final String token = results.getToken();
        // if we have a token, we can scroll through additional results, else there's nothing to do.
        results =
                (token != null) ?
                        this.vimPort.continueRetrievePropertiesEx(propertyCollector, token) : null;
    }

    return tgtMoref;
}

public static String populate(final RetrieveResult rslts,
        final List<ObjectContent> listobjcontent) {
    String token = null;
    if (rslts != null) {
        token = rslts.getToken();
        listobjcontent.addAll(rslts.getObjects());
    }
    return token;
}

/**
 * Uses the new RetrievePropertiesEx method to emulate the now deprecated
 * RetrieveProperties method.
 *
 * @param listpfs
 * @return list of object content
 * @throws Exception
 */
public static List<ObjectContent> retrievePropertiesAllObjects(
        VimPortType vimPort, ManagedObjectReference propCollectorRef,
        List<PropertyFilterSpec> listpfs)
        throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg {
    RetrieveOptions propObjectRetrieveOpts = new RetrieveOptions();
    List<ObjectContent> listobjcontent = new ArrayList<ObjectContent>();

    RetrieveResult rslts = vimPort.retrievePropertiesEx(propCollectorRef,
            listpfs, propObjectRetrieveOpts);
    if (rslts != null && rslts.getObjects() != null
            && !rslts.getObjects().isEmpty()) {
        listobjcontent.addAll(rslts.getObjects());
    }
    String token = null;
    if (rslts != null && rslts.getToken() != null) {
        token = rslts.getToken();
    }
    while (token != null && !token.isEmpty()) {
        rslts = vimPort.continueRetrievePropertiesEx(propCollectorRef,
                token);
        token = null;
        if (rslts != null) {
            token = rslts.getToken();
            if (rslts.getObjects() != null
                    && !rslts.getObjects().isEmpty()) {
                listobjcontent.addAll(rslts.getObjects());
            }
        }
    }

    return listobjcontent;
}

/**
 * Uses the new RetrievePropertiesEx method to emulate the now deprecated
 * RetrieveProperties method
 *
 * @param filterSpecs
 * @return list of object content
 * @throws RuntimeFaultFaultMsg
 * @throws InvalidPropertyFaultMsg
 * @throws Exception
 */
private List<ObjectContent> retrievePropertiesAllObjects(
        List<PropertyFilterSpec> filterSpecs)
        throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg {

    RetrieveOptions retrieveOptions = new RetrieveOptions();
    ManagedObjectReference collector = serviceContent
            .getPropertyCollector();

    List<ObjectContent> contents = new ArrayList<ObjectContent>();

    RetrieveResult results = vimPort.retrievePropertiesEx(collector,
            filterSpecs, retrieveOptions);
    if (results != null && results.getObjects() != null
            && !results.getObjects().isEmpty()) {
        contents.addAll(results.getObjects());
    }
    String token = null;
    if (results != null && results.getToken() != null) {
        token = results.getToken();
    }
    while (token != null && token.length() > 0) {
        results = vimPort.continueRetrievePropertiesEx(collector, token);
        token = null;
        if (results != null) {
            token = results.getToken();
            if (results.getObjects() != null
                    && !results.getObjects().isEmpty()) {
                contents.addAll(results.getObjects());
            }
        }
    }

    return contents;
}

/**
 * initClusterHostMap is a self recursive method for generating VM/ESX to Cluster Hash Map.
 * In the first iteration it gathers all clusters and in consecutive calls for each cluster it updates Hash Map.
 * The logic here is use ComputeResource Entity as a base for gathering all virtual machines and ESX Hosts.
 * As part of configurations, GraphiteReceiver invokes this method at regular intervals (configured) and during runtime
 * if VM/ESX does not exist in the hash map.
 */
public static boolean initClusterHostMap(String clusterName, ManagedObjectReference rootFolder, ExecutionContext context, Map<String,String> clusterMap){
    try {
        if(clusterName == null){
            clusterMap.clear();
        }
        VimConnection connection = context.getConnection();
        RetrieveResult retrieveResult = getRetrieveResult(clusterName, connection, rootFolder);

        while((retrieveResult != null) && (retrieveResult.getObjects() != null) && (retrieveResult.getObjects().size() > 0)){

            String token = retrieveResult.getToken();

            for(ObjectContent objectContent : retrieveResult.getObjects()){
                List<DynamicProperty> dynamicProperties = objectContent.getPropSet();
                if(clusterName != null){
                    String dpsGet = String.valueOf(dynamicProperties.get(0).getVal());
                    clusterMap.put(dpsGet.replace(" ", "_"), clusterName.replace(" ", "_"));
                } else {
                    initClusterHostMap((String) (dynamicProperties.get(0).getVal()), objectContent.getObj(), context, clusterMap);
                }
            }

            if (token == null) {
                return true;
            }
            retrieveResult = connection.getVimPort().continueRetrievePropertiesEx(connection.getPropertyCollector(), token);
        }
        return true;
    } catch(Exception e){
        logger.fatal("Critical Error Detected.");
        logger.fatal(e.getLocalizedMessage());
        return false;
    }
}

private static RetrieveResult getRetrieveResult(String clusterName, VimConnection connection, ManagedObjectReference rootFolder) throws RuntimeFaultFaultMsg, InvalidPropertyFaultMsg {
    List<String> clusterList = new ArrayList<String>();
    clusterList.add("ComputeResource");
    clusterList.add("HostSystem");
    clusterList.add("VirtualMachine");

    ManagedObjectReference rootFolderAux = (clusterName == null)? connection.getRootFolder():rootFolder;
    ManagedObjectReference viewManager = connection.getVimPort().createContainerView(connection.getViewManager(), rootFolderAux, clusterList, true);

    if(viewManager == null) {
        logger.debug("cViewRef is null: " + clusterName);
        return null;
    }
    logger.debug("cViewRef is not null: " + clusterName);

    ObjectSpec objectSpec = new ObjectSpec();
    objectSpec.setObj(viewManager);
    objectSpec.setSkip(true);
    objectSpec.getSelectSet().add(getTraversalSpec(clusterName));

    PropertyFilterSpec propertyFilterSpec = new PropertyFilterSpec();
    propertyFilterSpec.getObjectSet().add(objectSpec);

    if(clusterName == null){
        propertyFilterSpec.getPropSet().add(getPropertySpec("ComputeResource"));
    }else{
        propertyFilterSpec.getPropSet().add(getPropertySpec("HostSystem"));
        propertyFilterSpec.getPropSet().add(getPropertySpec("VirtualMachine"));
    }
    List<PropertyFilterSpec> propertyFilterSpecs = new LinkedList<PropertyFilterSpec>();
    propertyFilterSpecs.add(propertyFilterSpec);
    return connection.getVimPort().retrievePropertiesEx(connection.getPropertyCollector(), propertyFilterSpecs, new RetrieveOptions());
}

/**
 * Uses the new RetrievePropertiesEx method to emulate the now deprecated
 * RetrieveProperties method
 *
 * @param propertyFilterSpecList
 * @return list of object content
 * @throws Exception
 */
private static List<ObjectContent> retrievePropertiesAllObjects(ConnectionResources connectionResources,
                                                               List<PropertyFilterSpec> propertyFilterSpecList)
        throws RuntimeFaultFaultMsg, InvalidPropertyFaultMsg {

    VimPortType vimPort = connectionResources.getVimPortType();
    ManagedObjectReference serviceInstance = connectionResources.getServiceInstance();
    ServiceContent serviceContent = vimPort.retrieveServiceContent(serviceInstance);
    ManagedObjectReference propertyCollectorReference = serviceContent.getPropertyCollector();
    RetrieveOptions propertyObjectRetrieveOptions = new RetrieveOptions();
    List<ObjectContent> objectContentList = new ArrayList<>();

    RetrieveResult results = vimPort.retrievePropertiesEx(propertyCollectorReference,
            propertyFilterSpecList,
            propertyObjectRetrieveOptions);

    if (results != null && results.getObjects() != null && !results.getObjects().isEmpty()) {
        objectContentList.addAll(results.getObjects());
    }

    String token = null;
    if (results != null && results.getToken() != null) {
        token = results.getToken();
    }

    while (token != null && !token.isEmpty()) {
        results = vimPort.continueRetrievePropertiesEx(propertyCollectorReference, token);
        token = null;
        if (results != null) {
            token = results.getToken();
            if (results.getObjects() != null && !results.getObjects().isEmpty()) {
                objectContentList.addAll(results.getObjects());
            }
        }
    }

    return objectContentList;
}

/**
 * Initialize the helper object on the current connection at invocation time. Do not initialize on construction
 * since the connection may not be ready yet.
 */

private RetrieveResult containerViewByType(final ManagedObjectReference container,
                                           final String morefType,
                                           final RetrieveOptions retrieveOptions
) throws RuntimeFaultFaultMsg, InvalidPropertyFaultMsg {
    return this.containerViewByType(container, morefType, retrieveOptions, ManagedObjectType.NAME.getValue());
}

private Map<String, ManagedObjectReference> toMap(RetrieveResult result)
        throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg {
    final Map<String, ManagedObjectReference> tgtMoref = new HashMap<>();

    String token = populate(result, tgtMoref);
    while (token != null && !token.isEmpty()) {
        // fetch results based on new token
        result = vimPort.continueRetrievePropertiesEx(serviceContent.getPropertyCollector(), token);
        token = populate(result, tgtMoref);
    }

    return tgtMoref;
}

private ManagedObjectReference findComponentReference(final PropertyFilterSpec[] propertyFilterSpecs,
                                                      final RetrieveOptions retrieveOptions, final String id) throws Exception {
    String token = null;
    ManagedObjectReference searched;
    do {
        final RetrieveResult retrieveResult = retrievePropertiesEx(Arrays.asList(propertyFilterSpecs), retrieveOptions, token);
        token = retrieveResult.getToken();
        searched = getFromRetrieveResult(retrieveResult, id);
    } while (searched == null && StringUtilities.isNotEmpty(token));
    return searched;
}

private RetrieveResult retrievePropertiesEx(final List<PropertyFilterSpec> propertyFilterSpecs, final RetrieveOptions retrieveOptions,
                                            final String token) throws Exception {
    if (isEmpty(token)) {
        return vimPort.retrievePropertiesEx(serviceContent.getPropertyCollector(), propertyFilterSpecs, retrieveOptions);
    }
    return vimPort.continueRetrievePropertiesEx(serviceContent.getPropertyCollector(), token);
}

private ManagedObjectReference getFromRetrieveResult(final RetrieveResult retrieveResult, final String id) {
    for (final ObjectContent oc : retrieveResult.getObjects()) {
        if (StringUtilities.equals(id, oc.getObj().getValue())) {
            return oc.getObj();
        }
    }
    return null;
}

/**
 * Get the MOR of the Virtual Machine by its name.
 *
 * @param vmName           The name of the Virtual Machine
 * @param propCollectorRef
 * @return The Managed Object reference for this VM
 * @throws RuntimeFaultFaultMsg
 * @throws InvalidPropertyFaultMsg
 */
public ManagedObjectReference vmByVMname(
        final String vmName, final ManagedObjectReference propCollectorRef
) throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg {

    init();

    ManagedObjectReference rootFolder = this.serviceContent.getRootFolder();
    TraversalSpec tSpec = getVMTraversalSpec();
    // Create Property Spec
    PropertySpec propertySpec = new PropertySpecBuilder()
            .all(Boolean.FALSE)
            .pathSet("name")
            .type("VirtualMachine");

    // Now create Object Spec
    ObjectSpec objectSpec = new ObjectSpecBuilder()
            .obj(rootFolder)
            .skip(Boolean.TRUE)
            .selectSet(tSpec);

    // Create PropertyFilterSpec using the PropertySpec and ObjectPec
    // created above.
    PropertyFilterSpec propertyFilterSpec = new PropertyFilterSpecBuilder()
            .propSet(propertySpec)
            .objectSet(objectSpec);

    List<PropertyFilterSpec> listpfs =
            new ArrayList<PropertyFilterSpec>(1);
    listpfs.add(propertyFilterSpec);
    RetrieveOptions options = new RetrieveOptions();
    // Query returns a fixed number of results
    // if token is returned we can get more results
    RetrieveResult retrieveResult =
            this.vimPort.retrievePropertiesEx(propCollectorRef, listpfs, options);
    String token = null;

    do {
        token = (retrieveResult != null) ? retrieveResult.getToken() : null;
        List<ObjectContent> listobcont =
                (retrieveResult != null) ?
                        retrieveResult.getObjects() : null;

        if (listobcont != null) {
            for (ObjectContent oc : listobcont) {
                ManagedObjectReference mr = oc.getObj();
                String vmnm = null;
                List<DynamicProperty> dps = oc.getPropSet();
                if (dps != null) {
                    for (DynamicProperty dp : dps) {
                        vmnm = (String) dp.getVal();
                        if (vmName.equals(vmnm)) {
                            return mr;
                        }
                    }
                }
            }
        }
        if (token != null) {
            retrieveResult = this.vimPort.continueRetrievePropertiesEx(propCollectorRef, token);
        }
    } while (token != null);

    return null;
}

/**
 * Method to retrieve properties of list of {@link ManagedObjectReference}
 *
 * @param entityMors List of {@link ManagedObjectReference} for which the properties
 *                   needs to be retrieved
 * @param props      Common properties that need to be retrieved for all the
 *                   {@link ManagedObjectReference} passed
 * @return Map of {@link ManagedObjectReference} and their corresponding name
 *         value pair of properties
 * @throws InvalidPropertyFaultMsg
 * @throws RuntimeFaultFaultMsg
 */
public Map<ManagedObjectReference, Map<String, Object>> entityProps(
        List<ManagedObjectReference> entityMors, String[] props)
        throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg {
    init();

    Map<ManagedObjectReference, Map<String, Object>> retVal =
            new HashMap<ManagedObjectReference, Map<String, Object>>();
    // Create PropertyFilterSpec
    PropertyFilterSpecBuilder propertyFilterSpec = new PropertyFilterSpecBuilder();
    Map<String, String> typesCovered = new HashMap<String, String>();

    for (ManagedObjectReference mor : entityMors) {
        if (!typesCovered.containsKey(mor.getType())) {
            // Create & add new property Spec
            propertyFilterSpec.propSet(
                    new PropertySpecBuilder()
                            .all(Boolean.FALSE)
                            .type(mor.getType())
                            .pathSet(props)
            );
            typesCovered.put(mor.getType(), "");
        }
        // Now create & add Object Spec
        propertyFilterSpec.objectSet(
                new ObjectSpecBuilder().obj(mor)
        );
    }
    List<PropertyFilterSpec> propertyFilterSpecs =
            new ArrayList<PropertyFilterSpec>();
    propertyFilterSpecs.add(propertyFilterSpec);

    RetrieveResult rslts =
            this.vimPort.retrievePropertiesEx(this.serviceContent.getPropertyCollector(),
                    propertyFilterSpecs, new RetrieveOptions());

    List<ObjectContent> listobjcontent = new ArrayList<ObjectContent>();
    String token = populate(rslts, listobjcontent);
    while (token != null && !token.isEmpty()) {
        rslts =
                this.vimPort.continueRetrievePropertiesEx(
                        this.serviceContent.getPropertyCollector(), token);

        token = populate(rslts, listobjcontent);
    }

    for (ObjectContent oc : listobjcontent) {
        List<DynamicProperty> dps = oc.getPropSet();
        Map<String, Object> propMap = new HashMap<String, Object>();
        if (dps != null) {
            for (DynamicProperty dp : dps) {
                propMap.put(dp.getName(), dp.getVal());
            }
        }
        retVal.put(oc.getObj(), propMap);
    }
    return retVal;
}

/** @since SDK4.1 */
public RetrieveResult continueRetrievePropertiesEx(String token) throws InvalidProperty, RuntimeFault, RemoteException
{
  return getVimService().continueRetrievePropertiesEx(getMOR(), token);
}

/** @since SDK4.1 */
public RetrieveResult retrievePropertiesEx(PropertyFilterSpec[] specSet, RetrieveOptions options) throws InvalidProperty, RuntimeFault, RemoteException
{
  return getVimService().retrievePropertiesEx(getMOR(), specSet, options);
}

private RetrieveResult containerViewByType(final RetrieveOptions retrieveOptions,
                                           final PropertyFilterSpec... propertyFilterSpecs)
        throws RuntimeFaultFaultMsg, InvalidPropertyFaultMsg {
    return vimPort.retrievePropertiesEx(serviceContent.getPropertyCollector(), Arrays.asList(propertyFilterSpecs),
            retrieveOptions);
}

public static Map<String, Object> getEntityProps(VMwareConnection connection, ManagedObjectReference entityMor, String[] props)
        throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg {
    Map<String, Object> retVal = new HashMap<>();

    PropertySpec propertySpec = new PropertySpec();

    propertySpec.setAll(Boolean.FALSE);
    propertySpec.setType(entityMor.getType());
    propertySpec.getPathSet().addAll(Arrays.asList(props));

    ObjectSpec objectSpec = new ObjectSpec();

    objectSpec.setObj(entityMor);

    // Create PropertyFilterSpec using the PropertySpec and ObjectPec created above.
    PropertyFilterSpec propertyFilterSpec = new PropertyFilterSpec();

    propertyFilterSpec.getPropSet().add(propertySpec);
    propertyFilterSpec.getObjectSet().add(objectSpec);

    List<PropertyFilterSpec> propertyFilterSpecs = new ArrayList<>();

    propertyFilterSpecs.add(propertyFilterSpec);

    RetrieveResult rslts = connection.getVimPortType().retrievePropertiesEx(connection.getServiceContent().getPropertyCollector(),
            propertyFilterSpecs, new RetrieveOptions());
    List<ObjectContent> listobjcontent = new ArrayList<>();

    if (rslts != null && rslts.getObjects() != null && !rslts.getObjects().isEmpty()) {
        listobjcontent.addAll(rslts.getObjects());
    }

    String token = null;

    if (rslts != null && rslts.getToken() != null) {
        token = rslts.getToken();
    }

    while (token != null && !token.isEmpty()) {
        rslts = connection.getVimPortType().continueRetrievePropertiesEx(connection.getServiceContent().getPropertyCollector(),
                token);

        token = null;

        if (rslts != null) {
            token = rslts.getToken();

            if (rslts.getObjects() != null && !rslts.getObjects().isEmpty()) {
                listobjcontent.addAll(rslts.getObjects());
            }
        }
    }

    for (ObjectContent oc : listobjcontent) {
        List<DynamicProperty> dps = oc.getPropSet();

        if (dps != null) {
            for (DynamicProperty dp : dps) {
                retVal.put(dp.getName(), dp.getVal());
            }
        }
    }

    return retVal;
}

/**
 * Returns all the MOREFs of the specified type that are present under the
 * container
 *
 * @param folder    {@link ManagedObjectReference} of the container to begin the
 *                  search from
 * @param morefType Type of the managed entity that needs to be searched
 * @return Map of name and MOREF of the managed objects present. If none
 *         exist then empty Map is returned
 * @throws InvalidPropertyFaultMsg
 * @throws RuntimeFaultFaultMsg
 */
public Map<String, ManagedObjectReference> inContainerByType(
        ManagedObjectReference folder, String morefType, RetrieveOptions retrieveOptions)
        throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg {

    init();
    RetrieveResult rslts = containerViewByType(folder, morefType, retrieveOptions);
    return toMap(rslts);
}

/**
 * Returns all the MOREFs of the specified type that are present under the
 * container
 *
 * @param folder    {@link ManagedObjectReference} of the container to begin the
 *                  search from
 * @param morefType Type of the managed entity that needs to be searched
 * @return Map of name and MOREF of the managed objects present. If none
 *         exist then empty Map is returned
 * @throws InvalidPropertyFaultMsg
 * @throws RuntimeFaultFaultMsg
 */
public Map<String, ManagedObjectReference> inContainerByType(ManagedObjectReference folder,
                                                             String morefType,
                                                             RetrieveOptions retrieveOptions)
        throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg {
    RetrieveResult results = containerViewByType(folder, morefType, retrieveOptions);

    return toMap(results);
}

/**
 * Returns the raw RetrieveResult object for the provided container filtered on properties list
 *
 * @param container       - container to look in
 * @param morefType       - type to filter for
 * @param morefProperties - properties to include
 * @return com.vmware.vim25.RetrieveResult for this query
 * @throws RuntimeFaultFaultMsg
 * @throws InvalidPropertyFaultMsg
 */
private RetrieveResult containerViewByType(final ManagedObjectReference container,
                                           final String morefType,
                                           final RetrieveOptions retrieveOptions,
                                           final String... morefProperties
) throws RuntimeFaultFaultMsg, InvalidPropertyFaultMsg {
    PropertyFilterSpec[] propertyFilterSpecs = propertyFilterSpecs(container, morefType, morefProperties);

    return containerViewByType(retrieveOptions, propertyFilterSpecs);
}