Examples with ECSStoragePort com.emc.storageos.ecs.api.ECSStoragePort used on opensource projects

Example 1 with ECSStoragePort

use of com.emc.storageos.ecs.api.ECSStoragePort in project coprhd-controller by CoprHD.

the class ECSCommunicationInterface method discover.

/**
 * Get storage pool and storage ports
 */
@Override
public void discover(AccessProfile accessProfile) throws BaseCollectionException {
    URI storageSystemId = null;
    StorageSystem storageSystem = null;
    String detailedStatusMessage = "Unknown Status";
    long startTime = System.currentTimeMillis();
    _logger.info("ECSCommunicationInterface:discover Access Profile Details :" + accessProfile.toString());
    try {
        storageSystemId = accessProfile.getSystemId();
        storageSystem = _dbClient.queryObject(StorageSystem.class, storageSystemId);
        // try to connect to the ECS
        ECSApi ecsApi = getECSDevice(storageSystem);
        String authToken = ecsApi.getAuthToken();
        if (authToken.isEmpty()) {
            throw ECSException.exceptions.discoverFailed("Could not obtain authToken");
        }
        // Make sure user is system admin before proceeding to discovery
        if (!ecsApi.isSystemAdmin()) {
            _logger.error("User:" + accessProfile.getUserName() + "dont have privileges to access Elastic Cloud Storage: " + accessProfile.getIpAddress());
            _logger.error("Discovery failed");
            throw ECSException.exceptions.discoverFailed("User is not ECS System Admin");
        }
        String ecsVersion = ecsApi.getECSVersion();
        String ecsSerialNumber = ecsApi.getECSSerialNum();
        // Get details of storage system
        String nativeGuid = NativeGUIDGenerator.generateNativeGuid(DiscoveredDataObject.Type.ecs.toString(), ecsSerialNumber);
        storageSystem.setNativeGuid(nativeGuid);
        storageSystem.setSerialNumber(ecsSerialNumber);
        storageSystem.setFirmwareVersion(ecsVersion);
        storageSystem.setUsername(accessProfile.getUserName());
        storageSystem.setPassword(accessProfile.getPassword());
        storageSystem.setPortNumber(accessProfile.getPortNumber());
        storageSystem.setIpAddress(accessProfile.getIpAddress());
        storageSystem.setCompatibilityStatus(DiscoveredDataObject.CompatibilityStatus.COMPATIBLE.name());
        storageSystem.setReachableStatus(true);
        storageSystem.setInactive(false);
        _dbClient.persistObject(storageSystem);
        // Discover storage pools
        Map<String, List<StoragePool>> allPools = new HashMap<String, List<StoragePool>>();
        List<StoragePool> newPools = new ArrayList<StoragePool>();
        List<StoragePool> existingPools = new ArrayList<StoragePool>();
        StoragePool storagePool;
        List<ECSStoragePool> ecsStoragePools = ecsApi.getStoragePools();
        for (ECSStoragePool ecsPool : ecsStoragePools) {
            // Check if this storage pool was already discovered
            storagePool = null;
            String storagePoolNativeGuid = NativeGUIDGenerator.generateNativeGuid(storageSystem, ecsPool.getId(), NativeGUIDGenerator.POOL);
            @SuppressWarnings("deprecation") List<URI> poolURIs = _dbClient.queryByConstraint(AlternateIdConstraint.Factory.getStoragePoolByNativeGuidConstraint(storagePoolNativeGuid));
            for (URI poolUri : poolURIs) {
                StoragePool pool = _dbClient.queryObject(StoragePool.class, poolUri);
                if (!pool.getInactive() && pool.getStorageDevice().equals(storageSystemId)) {
                    storagePool = pool;
                    break;
                }
            }
            if (storagePool == null) {
                storagePool = new StoragePool();
                storagePool.setId(URIUtil.createId(StoragePool.class));
                storagePool.setNativeId(ecsPool.getId());
                storagePool.setNativeGuid(storagePoolNativeGuid);
                storagePool.setLabel(storagePoolNativeGuid);
                storagePool.setPoolClassName("ECS Pool");
                storagePool.setStorageDevice(storageSystem.getId());
                StringSet protocols = new StringSet();
                protocols.add("S3");
                protocols.add("Swift");
                protocols.add("Atmos");
                storagePool.setProtocols(protocols);
                storagePool.setPoolName(ecsPool.getName());
                storagePool.setOperationalStatus(StoragePool.PoolOperationalStatus.READY.toString());
                storagePool.setPoolServiceType(PoolServiceType.object.toString());
                storagePool.setRegistrationStatus(RegistrationStatus.REGISTERED.toString());
                storagePool.setSupportedResourceTypes(StoragePool.SupportedResourceTypes.THICK_ONLY.toString());
                storagePool.setFreeCapacity(ecsPool.getFreeCapacity() * BYTESCONVERTER * BYTESCONVERTER);
                storagePool.setTotalCapacity(ecsPool.getTotalCapacity() * BYTESCONVERTER * BYTESCONVERTER);
                storagePool.setInactive(false);
                storagePool.setDataCenters(ecsPool.getTotalDataCenters());
                _logger.info("Creating new ECS storage pool using NativeId : {}", storagePoolNativeGuid);
                storagePool.setDiscoveryStatus(DiscoveryStatus.VISIBLE.name());
                storagePool.setCompatibilityStatus(DiscoveredDataObject.CompatibilityStatus.COMPATIBLE.name());
                newPools.add(storagePool);
            } else {
                existingPools.add(storagePool);
            }
        }
        allPools.put(NEW, newPools);
        allPools.put(EXISTING, existingPools);
        _logger.info("No of newly discovered pools {}", allPools.get(NEW).size());
        _logger.info("No of existing discovered pools {}", allPools.get(EXISTING).size());
        if (!allPools.get(NEW).isEmpty()) {
            _dbClient.createObject(allPools.get(NEW));
        }
        if (!allPools.get(EXISTING).isEmpty()) {
            _dbClient.persistObject(allPools.get(EXISTING));
        }
        // Get storage ports
        HashMap<String, List<StoragePort>> storagePorts = new HashMap<String, List<StoragePort>>();
        List<StoragePort> newStoragePorts = new ArrayList<StoragePort>();
        List<StoragePort> existingStoragePorts = new ArrayList<StoragePort>();
        List<ECSStoragePort> ecsStoragePorts = ecsApi.getStoragePort(storageSystem.getIpAddress());
        for (ECSStoragePort ecsPort : ecsStoragePorts) {
            StoragePort storagePort = null;
            String portNativeGuid = NativeGUIDGenerator.generateNativeGuid(storageSystem, ecsPort.getIpAddress(), NativeGUIDGenerator.PORT);
            // Check if storage port was already discovered
            @SuppressWarnings("deprecation") List<URI> portURIs = _dbClient.queryByConstraint(AlternateIdConstraint.Factory.getStoragePortByNativeGuidConstraint(portNativeGuid));
            for (URI portUri : portURIs) {
                StoragePort port = _dbClient.queryObject(StoragePort.class, portUri);
                if (port.getStorageDevice().equals(storageSystemId) && !port.getInactive()) {
                    storagePort = port;
                    break;
                }
            }
            if (storagePort == null) {
                // Create new port
                storagePort = new StoragePort();
                storagePort.setId(URIUtil.createId(StoragePort.class));
                storagePort.setTransportType("IP");
                storagePort.setNativeGuid(portNativeGuid);
                storagePort.setLabel(portNativeGuid);
                storagePort.setStorageDevice(storageSystemId);
                storagePort.setPortNetworkId(ecsPort.getIpAddress().toLowerCase());
                storagePort.setPortName(ecsPort.getName());
                storagePort.setLabel(ecsPort.getName());
                storagePort.setPortGroup(ecsPort.getName());
                storagePort.setRegistrationStatus(RegistrationStatus.REGISTERED.toString());
                storagePort.setOperationalStatus(StoragePort.OperationalStatus.OK.toString());
                _logger.info("Creating new storage port using NativeGuid : {}", portNativeGuid);
                newStoragePorts.add(storagePort);
            } else {
                existingStoragePorts.add(storagePort);
            }
            storagePort.setDiscoveryStatus(DiscoveryStatus.VISIBLE.name());
            storagePort.setCompatibilityStatus(DiscoveredDataObject.CompatibilityStatus.COMPATIBLE.name());
        }
        storagePorts.put(NEW, newStoragePorts);
        storagePorts.put(EXISTING, existingStoragePorts);
        _logger.info("No of newly discovered ports {}", storagePorts.get(NEW).size());
        _logger.info("No of existing discovered ports {}", storagePorts.get(EXISTING).size());
        if (!storagePorts.get(NEW).isEmpty()) {
            _dbClient.createObject(storagePorts.get(NEW));
        }
        if (!storagePorts.get(EXISTING).isEmpty()) {
            _dbClient.persistObject(storagePorts.get(EXISTING));
        }
        // Discover ECS Namespaces
        List<ObjectNamespace> allNamespaces = new ArrayList<ObjectNamespace>();
        Map<String, List<ObjectNamespace>> bothNamespaces = discoverNamespaces(storageSystem);
        _logger.info("No of newly discovered namespaces {}", bothNamespaces.get(NEW).size());
        _logger.info("No of existing discovered namespaces {}", bothNamespaces.get(EXISTING).size());
        if (bothNamespaces != null && !bothNamespaces.get(NEW).isEmpty()) {
            allNamespaces.addAll(bothNamespaces.get(NEW));
            _dbClient.createObject(bothNamespaces.get(NEW));
        }
        if (bothNamespaces != null && !bothNamespaces.get(EXISTING).isEmpty()) {
            allNamespaces.addAll(bothNamespaces.get(EXISTING));
            _dbClient.updateObject(bothNamespaces.get(EXISTING));
        }
        // Some namespaces might have been deleted
        DiscoveryUtils.checkNamespacesNotVisible(allNamespaces, _dbClient, storageSystemId);
        _completer.statusPending(_dbClient, "Completed namespace discovery");
        // Discovery success
        detailedStatusMessage = String.format("Discovery completed successfully for ECS: %s", storageSystemId.toString());
    } catch (Exception e) {
        if (storageSystem != null) {
            cleanupDiscovery(storageSystem);
        }
        detailedStatusMessage = String.format("Discovery failed for Storage System ECS %s: because %s", storageSystemId.toString(), e.getLocalizedMessage());
        _logger.error(detailedStatusMessage, e);
        throw new ECSCollectionException(false, ServiceCode.DISCOVERY_ERROR, null, detailedStatusMessage, null, null);
    } finally {
        if (storageSystem != null) {
            try {
                // set detailed message
                storageSystem.setLastDiscoveryStatusMessage(detailedStatusMessage);
                _dbClient.persistObject(storageSystem);
            } catch (DatabaseException ex) {
                _logger.error("Error while persisting object to DB", ex);
            }
        }
        long totalTime = System.currentTimeMillis() - startTime;
        _logger.info(String.format("Discovery of ECS Storage System %s took %f seconds", accessProfile.getIpAddress(), (double) totalTime / (double) 1000));
    }
}