Examples with InvalidSession com.vmware.vim.vasa._1_0.InvalidSession used on opensource projects

Example 21 with InvalidSession

use of com.vmware.vim.vasa._1_0.InvalidSession in project coprhd-controller by CoprHD.

the class SOSManager method getUsageContext.

private UsageContext getUsageContext() throws InvalidSession, StorageFault {
    _contextManager = ContextManagerImpl.getInstance();
    UsageContext uc = _contextManager.getUsageContext();
    return uc;
}

Example 22 with InvalidSession

use of com.vmware.vim.vasa._1_0.InvalidSession in project coprhd-controller by CoprHD.

the class SOSManager method queryStorageCapabilities.

/**
 * Makes a call to Bourne to get the details of given storage capability Ids
 *
 * @param capId
 * @return array of <code>StorageCapability</code> objects
 * @throws InvalidArgument
 * @throws InvalidSession
 * @throws StorageFault
 * @throws NotImplemented
 */
public synchronized StorageCapability[] queryStorageCapabilities(String[] capIds) throws InvalidArgument, InvalidSession, StorageFault, NotImplemented {
    final String methodName = "queryStorageCapabilities(): ";
    log.debug(methodName + "Entry");
    List<StorageCapability> returnList = null;
    List<CoS> cosList = null;
    try {
        Boolean supportsCapability = new Boolean(_config.getConfigValue("config/service/storageTopology/storageArray/support-capability-profile"));
        if (!supportsCapability) {
            log.error(methodName + " This function is not implemented");
            throw FaultUtil.NotImplemented("This function is not implemented");
        }
        if (Util.isEmpty(capIds)) {
            log.debug(methodName + "input capability Ids: " + capIds);
            cosList = _syncManager.getCosDetailList();
        } else {
            for (String inputCapId : capIds) {
                if (!Util.isEmpty(inputCapId)) {
                    if (!inputCapId.startsWith(COS_IDENTIFIER_PREFIX)) {
                        throw FaultUtil.InvalidArgument("Storage capability Id is invalid: " + inputCapId);
                    }
                } else {
                    throw FaultUtil.InvalidArgument("Storage capability Id is empty: " + inputCapId);
                }
            }
            List<String> inputCapIdList = Arrays.asList(capIds);
            log.debug(methodName + "input capability Ids: " + inputCapIdList);
            cosList = _syncManager.getCosDetailList(inputCapIdList);
        }
        returnList = new ArrayList<StorageCapability>();
        for (CoS cos : cosList) {
            StorageCapability capability = new StorageCapability();
            capability.setUniqueIdentifier(cos.getId());
            capability.setCapabilityName(cos.getLabel() + ":" + cos.getType());
            capability.setCapabilityDetail(cos.getDescription());
            if (log.isDebugEnabled()) {
                log.debug(methodName + "Capability detail: id[" + capability.getUniqueIdentifier() + "] name[" + capability.getCapabilityName() + "] detail[" + capability.getCapabilityDetail() + "]");
            }
            returnList.add(capability);
        }
    } catch (SOSFailure e) {
        log.error(methodName + "StorageOSFailure occured ", e);
        throw FaultUtil.StorageFault(e);
    } catch (InvalidArgument e) {
        log.error(methodName + "InvalidArgument occured ", e);
        throw e;
    } catch (NotImplemented e) {
        log.error(methodName + "NotImplemented occured ", e);
        throw e;
    }
    return returnList.toArray(new StorageCapability[0]);
}

Example 23 with InvalidSession

use of com.vmware.vim.vasa._1_0.InvalidSession in project coprhd-controller by CoprHD.

the class SOSManager method queryAssociatedLUNsForPort.

/**
 * Makes a call to Bourne to get the associated Luns for the given storage
 * port Ids
 *
 * @param portUniqueIds
 * @return array of <code>VasaAssociationObject</code> objects
 * @throws InvalidArgument
 * @throws InvalidSession
 * @throws StorageFault
 * @throws NotImplemented
 */
public synchronized VasaAssociationObject[] queryAssociatedLUNsForPort(String[] portUniqueIds) throws InvalidArgument, InvalidSession, StorageFault, NotImplemented {
    final String methodName = "queryAssociatedLUNsForPort(): ";
    log.debug(methodName + "Entry");
    List<VasaAssociationObject> returnList = null;
    List<String> inputPortIdList = null;
    log.info(methodName + "Input:[" + portUniqueIds + "]");
    try {
        Boolean supportsBlock = new Boolean(_config.getConfigValue("config/service/storageTopology/storageArray/support-block-profile"));
        if (!supportsBlock) {
            log.error(methodName + " This function is not implemented");
            throw FaultUtil.NotImplemented("This function is not implemented");
        }
        String csvSeparatedInitiatorList = this.getCSVListOfInitiatorsFromUsageContext();
        Hashtable<String, List<String>> portToVolumeTable = _syncManager.getStoragePortToVolumeTable(csvSeparatedInitiatorList);
        returnList = new ArrayList<VasaAssociationObject>();
        if (Util.isEmpty(portUniqueIds)) {
            // Return all port associated to LUNs
            for (String portId : portToVolumeTable.keySet()) {
                VasaAssociationObject associationObject = new VasaAssociationObject();
                BaseStorageEntity storagePort = new BaseStorageEntity();
                storagePort.setUniqueIdentifier(portId);
                associationObject.addEntityId(storagePort);
                for (String volumeId : portToVolumeTable.get(portId)) {
                    BaseStorageEntity associatedVolume = new BaseStorageEntity();
                    associatedVolume.setUniqueIdentifier(volumeId);
                    associationObject.addAssociatedId(associatedVolume);
                }
                returnList.add(associationObject);
            }
        } else {
            inputPortIdList = Arrays.asList(portUniqueIds);
            log.debug(methodName + "Input port ids: " + inputPortIdList);
            for (String inputPortId : inputPortIdList) {
                if (!Util.isEmpty(inputPortId)) {
                    if (!inputPortId.startsWith(STORAGEPORT_IDENTIFIER_PREFIX)) {
                        throw FaultUtil.InvalidArgument("Given port Id is invalid[" + inputPortId + "]");
                    } else {
                        List<String> volumeIdList = portToVolumeTable.get(inputPortId);
                        if (volumeIdList != null && !volumeIdList.isEmpty()) {
                            VasaAssociationObject associationObject = new VasaAssociationObject();
                            BaseStorageEntity storagePort = new BaseStorageEntity();
                            storagePort.setUniqueIdentifier(inputPortId);
                            associationObject.addEntityId(storagePort);
                            for (String volumeId : volumeIdList) {
                                BaseStorageEntity associatedVolume = new BaseStorageEntity();
                                associatedVolume.setUniqueIdentifier(volumeId);
                                associationObject.addAssociatedId(associatedVolume);
                            }
                            returnList.add(associationObject);
                        }
                    }
                }
            // }
            }
        }
        return returnList.toArray(new VasaAssociationObject[0]);
    } catch (SOSFailure e) {
        log.error("StorageOSFailure occured", e);
        throw FaultUtil.StorageFault("StorageOSFailure occured", e);
    } catch (InvalidArgument e) {
        log.error(methodName + "InvalidArgument occured ", e);
        throw e;
    } catch (NotImplemented e) {
        log.error(methodName + "NotImplemented occured ", e);
        throw e;
    }
}

Example 24 with InvalidSession

use of com.vmware.vim.vasa._1_0.InvalidSession in project coprhd-controller by CoprHD.

the class SOSManager method queryAssociatedPortsForProcessor.

/**
 * Makes a call to Bourne to get the associated ports for the given storage
 * processor Ids
 *
 * @param spUniqueIds
 * @return array of <code>VasaAssociationObject</code> objects
 * @throws InvalidArgument
 * @throws InvalidSession
 * @throws StorageFault
 * @throws NotImplemented
 */
public synchronized VasaAssociationObject[] queryAssociatedPortsForProcessor(String[] spUniqueIds) throws InvalidArgument, InvalidSession, StorageFault, NotImplemented {
    final String methodName = "queryAssociatedPortsForProcessor(): ";
    log.debug(methodName + "Entry");
    List<VasaAssociationObject> returnList = null;
    try {
        Boolean supportsBlock = new Boolean(_config.getConfigValue("config/service/storageTopology/storageArray/support-block-profile"));
        if (!supportsBlock) {
            log.error(methodName + " This function is not implemented");
            throw FaultUtil.NotImplemented("This function is not implemented");
        }
        String bourneProcessorId = this.getProcessorId();
        List<String> bourneStoragePortList = this.getStoragePortIds();
        returnList = new ArrayList<VasaAssociationObject>();
        if (!Util.isEmpty(spUniqueIds)) {
            List<String> inputPortIdList = Arrays.asList(spUniqueIds);
            log.debug(methodName + "input processor ids: " + inputPortIdList);
            for (String storageProcessorId : spUniqueIds) {
                if (!Util.isEmpty(storageProcessorId) && !storageProcessorId.startsWith(STORAGEPROCESSOR_IDENTIFIER_PREFIX)) {
                    throw FaultUtil.InvalidArgument("Given processor Id is invalid:[" + storageProcessorId + "]");
                }
                if (!Util.isEmpty(storageProcessorId) && bourneProcessorId.equals(storageProcessorId)) {
                    log.debug(methodName + "Input processor Id is matching with valid processor Id:[" + storageProcessorId + "]");
                    VasaAssociationObject associationObject = new VasaAssociationObject();
                    BaseStorageEntity entityObject = new BaseStorageEntity();
                    entityObject.setUniqueIdentifier(storageProcessorId);
                    associationObject.addEntityId(entityObject);
                    List<BaseStorageEntity> associatedPortList = new ArrayList<BaseStorageEntity>();
                    for (String bourneStoragePortId : bourneStoragePortList) {
                        BaseStorageEntity associatedPort = new BaseStorageEntity();
                        log.debug(methodName + "Associating storage port ID [" + bourneStoragePortId + "] to processor ID[" + storageProcessorId + "]");
                        associatedPort.setUniqueIdentifier(bourneStoragePortId);
                        associatedPortList.add(associatedPort);
                    }
                    associationObject.setAssociatedId(associatedPortList.toArray(new BaseStorageEntity[0]));
                    returnList.add(associationObject);
                }
            }
            log.debug(methodName + "Exit returning vasa association objects of size[" + returnList.size() + "]");
            return returnList.toArray(new VasaAssociationObject[0]);
        } else if (spUniqueIds != null && spUniqueIds.length == 0) {
            log.debug(methodName + "Exit returning vasa association objects of size[" + returnList.size() + "]");
            return returnList.toArray(new VasaAssociationObject[0]);
        }
        VasaAssociationObject associationObject = new VasaAssociationObject();
        BaseStorageEntity entityObject = new BaseStorageEntity();
        entityObject.setUniqueIdentifier(bourneProcessorId);
        associationObject.addEntityId(entityObject);
        List<BaseStorageEntity> associatedPortList = new ArrayList<BaseStorageEntity>();
        for (String bourneStoragePortId : bourneStoragePortList) {
            BaseStorageEntity associatedPort = new BaseStorageEntity();
            log.debug(methodName + "Associating storage port ID [" + bourneStoragePortId + "] to processor ID[" + bourneProcessorId + "]");
            associatedPort.setUniqueIdentifier(bourneStoragePortId);
            associatedPortList.add(associatedPort);
        }
        associationObject.setAssociatedId(associatedPortList.toArray(new BaseStorageEntity[0]));
        returnList.add(associationObject);
    } catch (InvalidArgument e) {
        log.error(methodName + "InvalidArgument occured ", e);
        throw e;
    } catch (NotImplemented e) {
        log.error(methodName + "NotImplemented occured ", e);
        throw e;
    } catch (StorageFault e) {
        log.error(methodName + "StorageFault occured ", e);
        throw e;
    }
    log.debug(methodName + "Exit returning vasa association objects of size[" + returnList.size() + "]");
    return returnList.toArray(new VasaAssociationObject[0]);
}

Example 25 with InvalidSession

use of com.vmware.vim.vasa._1_0.InvalidSession in project coprhd-controller by CoprHD.

the class SOSManager method queryArrays.

/**
 * Returns the storage array details for the given storage array Ids
 *
 * @param arrayId
 * @return array of <code>StorageArray</code> objects. Each having details
 *         of profiles the storage array supports
 * @throws InvalidArgument
 * @throws InvalidSession
 * @throws StorageFault
 */
public synchronized StorageArray[] queryArrays(String[] arrayId) throws InvalidArgument, InvalidSession, StorageFault {
    // Mandatory function
    final String methodName = "queryArrays(): ";
    log.debug(methodName + "Entry");
    List<StorageArray> storageArrayList = null;
    StorageArray[] arrays = null;
    if (!Util.isEmpty(arrayId)) {
        log.debug(methodName + "input array ids: " + Arrays.asList(arrayId));
    } else {
        log.debug(methodName + "input array ids: " + arrayId);
    }
    try {
        String sosArrayId = this.getArrayId();
        if (!Util.isEmpty(arrayId)) {
            storageArrayList = new ArrayList<StorageArray>();
            for (String inputArrayId : arrayId) {
                if (!inputArrayId.startsWith(STORAGEARRAY_IDENTIFIER_PREFIX)) {
                    throw FaultUtil.InvalidArgument("Given array Id is invalid:[" + arrayId + "]");
                }
                if (sosArrayId.equals(inputArrayId)) {
                    StorageArray storageArray = this.getSOSStorageArray();
                    storageArray.setUniqueIdentifier(inputArrayId);
                    storageArrayList.add(storageArray);
                }
            }
            return storageArrayList.toArray(new StorageArray[0]);
        }
        arrays = new StorageArray[1];
        StorageArray array = this.getSOSStorageArray();
        arrays[0] = array;
    } catch (StorageFault e) {
        log.error("StorageFault occured", e);
        throw e;
    } catch (InvalidArgument e) {
        log.error(methodName + "InvalidArgument occured ", e);
        throw e;
    }
    log.debug(methodName + "Exit returning arrays of size[" + arrays.length + "]");
    return arrays;
}