Examples with StorageArray com.vmware.vim.vasa._1_0.data.xsd.StorageArray used on opensource projects

Example 6 with StorageArray

use of com.vmware.vim.vasa._1_0.data.xsd.StorageArray in project coprhd-controller by CoprHD.

the class SOSManager method queryAssociatedCapabilityForFileSystem.

/**
 * Makes a call to Bourne to get the details of associated capability for
 * the given file system Ids
 *
 * @param fsId
 * @return array of <code>VasaAssociationObject</code> objects
 * @throws InvalidArgument
 * @throws InvalidSession
 * @throws StorageFault
 * @throws NotImplemented
 */
public synchronized VasaAssociationObject[] queryAssociatedCapabilityForFileSystem(String[] fsIds) throws InvalidArgument, InvalidSession, StorageFault, NotImplemented {
    final String methodName = "queryAssociatedCapabilityForFileSystem(): ";
    log.debug(methodName + "Entry");
    List<FileShare> fsList = null;
    List<VasaAssociationObject> returnList = null;
    Boolean supportsFile = new Boolean(_config.getConfigValue("config/service/storageTopology/storageArray/support-file-profile"));
    Boolean supportsCapability = new Boolean(_config.getConfigValue("config/service/storageTopology/storageArray/support-capability-profile"));
    try {
        if (supportsFile == false || supportsCapability == false) {
            log.error(methodName + " This function is not implemented");
            throw FaultUtil.NotImplemented("This function is not implemented");
        }
        this.setFileSystemIds();
        if (Util.isEmpty(fsIds)) {
            fsList = _syncManager.getFileSystemDetailList(this._reportedFileSystemIdList);
        } else {
            List<String> inputIdList = new ArrayList<String>();
            for (String inputFsId : fsIds) {
                if (!Util.isEmpty(inputFsId)) {
                    if (!inputFsId.startsWith(FILESYSTEM_IDENTIFIER_PREFIX)) {
                        throw FaultUtil.InvalidArgument("Given FileSystem Id is invalid: " + inputFsId);
                    }
                    if (_reportedFileSystemIdList.contains(inputFsId)) {
                        inputIdList.add(inputFsId);
                    }
                } else {
                    throw FaultUtil.InvalidArgument("Given FileSystem Id is invalid: " + inputFsId);
                }
            }
            log.debug(methodName + "input file system ids: " + inputIdList);
            fsList = _syncManager.getFileSystemDetailList(inputIdList);
        }
        returnList = new ArrayList<VasaAssociationObject>();
        for (FileShare fileShare : fsList) {
            VasaAssociationObject associationObject = new VasaAssociationObject();
            BaseStorageEntity assoc = new BaseStorageEntity();
            assoc.setUniqueIdentifier(fileShare.getCos().getId());
            BaseStorageEntity entity = new BaseStorageEntity();
            entity.setUniqueIdentifier(fileShare.getId());
            associationObject.addAssociatedId(assoc);
            associationObject.addEntityId(entity);
            log.debug(methodName + "File system id[" + entity.getUniqueIdentifier() + "] is associated to capability[" + assoc.getUniqueIdentifier() + "]");
            returnList.add(associationObject);
        }
    } catch (SOSFailure e1) {
        log.error(methodName + "StorageOSFailure occured ", e1);
        throw FaultUtil.StorageFault(e1);
    } catch (InvalidArgument e) {
        log.error(methodName + "InvalidArgument occured ", e);
        throw e;
    } catch (NotImplemented e) {
        log.error(methodName + "NotImplemented occured ", e);
        throw e;
    }
    log.debug(methodName + "Exit returning vasa association objects of size[" + returnList.size() + "]");
    return returnList.toArray(new VasaAssociationObject[0]);
}

Example 7 with StorageArray

use of com.vmware.vim.vasa._1_0.data.xsd.StorageArray in project coprhd-controller by CoprHD.

the class SOSManager method queryAssociatedProcessorsForArray.

/**
 * Makes a call to Bourne to get the associated processors for the given
 * storage array Ids
 *
 * @param arrayUniqueIds
 * @return array of <code>VasaAssociationObject</code> objects
 * @throws InvalidArgument
 * @throws InvalidSession
 * @throws StorageFault
 * @throws NotImplemented
 */
public synchronized VasaAssociationObject[] queryAssociatedProcessorsForArray(String[] arrayUniqueIds) throws InvalidArgument, StorageFault, NotImplemented, InvalidSession {
    final String methodName = "queryAssociatedProcessorsForArray(): ";
    List<VasaAssociationObject> returnList = null;
    String bourneArrayId = this.getArrayId();
    log.debug(methodName + "Entry");
    Boolean supportsBlock = new Boolean(_config.getConfigValue("config/service/storageTopology/storageArray/support-block-profile"));
    try {
        if (!supportsBlock) {
            log.error(methodName + " This function is not implemented");
            throw FaultUtil.NotImplemented("This function is not implemented");
        }
        if (!Util.isEmpty(arrayUniqueIds)) {
            List<String> inputArrayIdList = Arrays.asList(arrayUniqueIds);
            log.debug(methodName + "input array ids: " + inputArrayIdList);
            for (String inputArrayId : inputArrayIdList) {
                if (!Util.isEmpty(inputArrayId) && !inputArrayId.startsWith(STORAGEARRAY_IDENTIFIER_PREFIX)) {
                    throw FaultUtil.InvalidArgument("Given array Id is invalid:[" + inputArrayId + "]");
                }
            }
        }
        returnList = new ArrayList<VasaAssociationObject>();
        VasaAssociationObject associationObject = new VasaAssociationObject();
        BaseStorageEntity entity = new BaseStorageEntity();
        entity.setUniqueIdentifier(bourneArrayId);
        BaseStorageEntity associatedEntity = new BaseStorageEntity();
        associatedEntity.setUniqueIdentifier(this.getProcessorId());
        associationObject.addEntityId(entity);
        associationObject.addAssociatedId(associatedEntity);
        if (Util.isEmpty(arrayUniqueIds)) {
            log.debug(methodName + "Exit returning vasa association objects of size[" + returnList.size() + "]");
            returnList.add(associationObject);
        // return returnList.toArray(new VasaAssociationObject[0]);
        } else {
            /*
                 * StorageProcessor[] processorList = this
                 * .queryStorageProcessors(null);
                 */
            for (String arrayID : arrayUniqueIds) {
                if (bourneArrayId.equals(arrayID)) {
                    /*
                         * VasaAssociationObject associationObject = new
                         * VasaAssociationObject(); BaseStorageEntity entityObj
                         * = new BaseStorageEntity();
                         * entityObj.setUniqueIdentifier(arrayID);
                         * associationObject.addEntityId(entityObj);
                         */
                    // for (StorageProcessor proc : processorList) {
                    log.debug(methodName + "array[" + entity.getUniqueIdentifier() + "] is associated to processor[" + associatedEntity.getUniqueIdentifier() + "]");
                    returnList.add(associationObject);
                }
            // 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 8 with StorageArray

use of com.vmware.vim.vasa._1_0.data.xsd.StorageArray in project coprhd-controller by CoprHD.

the class SOSManager method queryStorageFileSystems.

/**
 * Makes a call to Bourne to get the details of given file system Ids
 *
 * @param filesystemIds
 * @return array of <code>StorageFileSystem</code> objects
 * @throws InvalidArgument
 * @throws InvalidSession
 * @throws StorageFault
 * @throws NotImplemented
 * @throws NotFound
 */
public synchronized StorageFileSystem[] queryStorageFileSystems(String[] fsUniqueIds) throws InvalidArgument, StorageFault, NotImplemented, InvalidSession {
    final String methodName = "queryStorageFileSystems(): ";
    log.debug(methodName + "Entry");
    List<StorageFileSystem> list = null;
    try {
        Boolean supportsFile = new Boolean(_config.getConfigValue("config/service/storageTopology/storageArray/support-file-profile"));
        if (!supportsFile) {
            log.error(methodName + " This function is not implemented");
            throw FaultUtil.NotImplemented("This function is not implemented");
        }
        if (Util.isEmpty(fsUniqueIds)) {
            throw FaultUtil.InvalidArgument("Given file system Ids are invalid");
        }
        for (String fsId : fsUniqueIds) {
            if (!Util.isEmpty(fsId)) {
                if (!fsId.startsWith(FILESYSTEM_IDENTIFIER_PREFIX)) {
                    throw FaultUtil.InvalidArgument("Given filesytem Id is invalid: " + fsId);
                }
            } else {
                throw FaultUtil.InvalidArgument("Given filesytem Id is invalid: " + fsId);
            }
        }
        this.setFileSystemIds();
        List<String> existingFsIdList = new ArrayList<String>();
        for (String inputFSId : fsUniqueIds) {
            if (_reportedFileSystemIdList.contains(inputFSId)) {
                existingFsIdList.add(inputFSId);
            }
        }
        list = new ArrayList<StorageFileSystem>();
        List<FileShare> fsList = _syncManager.getFileSystemDetailList(existingFsIdList);
        for (FileShare fileshare : fsList) {
            StorageFileSystem fileSystem = new StorageFileSystem();
            fileSystem.setUniqueIdentifier(fileshare.getId());
            if (fileshare.getProtocols().getProtocol().contains("NFS")) {
                fileSystem.setFileSystem(FileSystemEnum.NFS.getValue());
            } else if (fileshare.getProtocols().getProtocol().contains("NFSv4")) {
                fileSystem.setFileSystem(FileSystemEnum.NFS.getValue());
            } else {
                fileSystem.setFileSystem(FileSystemEnum.Other.getValue());
            }
            fileSystem.setFileSystemVersion(FileSystemVersionEnum.NFSV3_0.getValue());
            FileSystemInfo fsDetail = new FileSystemInfo();
            String fsNetworkId = "";
            if (fileshare.getStoragePort() != null && fileshare.getStorageController() != null) {
                String storageSystemId = fileshare.getStorageController().getId();
                String storagePortId = fileshare.getStoragePort().getId();
                com.emc.storageos.vasa.data.internal.StoragePort storagePort = _syncManager.getStoragePort(storageSystemId, storagePortId);
                fsNetworkId = storagePort.getPortNetworkId();
            }
            fsDetail.setIpAddress(fsNetworkId);
            fsDetail.setFileServerName(fsNetworkId);
            fsDetail.setFileSystemPath(fileshare.getMountPath());
            fileSystem.addFileSystemInfo(fsDetail);
            fileSystem.setNativeSnapshotSupported(true);
            fileSystem.setThinProvisioningStatus(AlarmStatusEnum.Green.getValue());
            if (log.isDebugEnabled()) {
                log.debug(methodName + "filesystem: id[" + fileSystem.getUniqueIdentifier() + "] type[" + fileSystem.getFileSystem() + "] version[" + fileSystem.getFileSystemVersion() + "] thinProvisioningStatus[" + fileSystem.getThinProvisioningStatus() + "] snapShotsupported[" + fileSystem.getNativeSnapshotSupported() + "] IpAddress[" + fileSystem.getFileSystemInfo()[0].getFileServerName() + "] serverName[" + fileSystem.getFileSystemInfo()[0].getFileServerName() + "] fileSystemPath[" + fileSystem.getFileSystemInfo()[0].getFileSystemPath() + "]");
            }
            list.add(fileSystem);
        }
    } 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;
    }
    log.debug(methodName + "Exit returning list of file systems of size[" + list.size() + "]");
    return list.toArray(new StorageFileSystem[0]);
}

Example 9 with StorageArray

use of com.vmware.vim.vasa._1_0.data.xsd.StorageArray 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 10 with StorageArray

use of com.vmware.vim.vasa._1_0.data.xsd.StorageArray 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;
    }
}