Examples with VNXeApiClient com.emc.storageos.vnxe.VNXeApiClient used on opensource projects

Example 26 with VNXeApiClient

use of com.emc.storageos.vnxe.VNXeApiClient in project coprhd-controller by CoprHD.

the class VNXeStorageDevice method updateExportRules.

@Override
public BiosCommandResult updateExportRules(StorageSystem storage, FileDeviceInputOutput args) {
    // Requested Export Rules
    List<ExportRule> exportAdd = args.getExportRulesToAdd();
    List<ExportRule> exportDelete = args.getExportRulesToDelete();
    List<ExportRule> exportModify = args.getExportRulesToModify();
    // To be processed export rules
    List<ExportRule> exportsToRemove = new ArrayList<>();
    List<ExportRule> exportsToAdd = new ArrayList<>();
    List<ExportRule> newExportsForDelete = new ArrayList<>();
    VNXeFileTaskCompleter completer = null;
    VNXeApiClient apiClient = getVnxeClient(storage);
    String subDir = args.getSubDirectory();
    // ALL EXPORTS
    List<ExportRule> exportsToprocess = args.getExistingDBExportRules();
    Map<String, ArrayList<ExportRule>> existingExportsMapped = new HashMap();
    try {
        String exportPath;
        if (!args.getFileOperation()) {
            exportPath = args.getSnapshotPath();
            if (subDir != null && subDir.length() > 0) {
                exportPath = args.getSnapshotPath() + "/" + subDir;
            }
        } else {
            exportPath = args.getFs().getPath();
            if (subDir != null && subDir.length() > 0) {
                exportPath = args.getFs().getPath() + "/" + subDir;
            }
        }
        _logger.info("exportPath : {}", exportPath);
        args.setExportPath(exportPath);
        try {
            // add the new export rule from the array into the update request.
            Map<String, ExportRule> arrayExportRuleMap = extraExportRuleFromArray(storage, args);
            if (!arrayExportRuleMap.isEmpty()) {
                if (exportModify != null) {
                    // merge the end point for which sec flavor is common.
                    for (ExportRule exportRule : exportModify) {
                        ExportRule arrayExportRule = arrayExportRuleMap.remove(exportRule.getSecFlavor());
                        if (arrayExportRule != null) {
                            if (exportRule.getReadOnlyHosts() != null) {
                                exportRule.getReadOnlyHosts().addAll(arrayExportRule.getReadOnlyHosts());
                            } else {
                                exportRule.setReadOnlyHosts(arrayExportRule.getReadOnlyHosts());
                            }
                            if (exportRule.getReadWriteHosts() != null) {
                                exportRule.getReadWriteHosts().addAll(arrayExportRule.getReadWriteHosts());
                            } else {
                                exportRule.setReadWriteHosts(arrayExportRule.getReadWriteHosts());
                            }
                            if (exportRule.getRootHosts() != null) {
                                exportRule.getRootHosts().addAll(arrayExportRule.getRootHosts());
                            } else {
                                exportRule.setRootHosts(arrayExportRule.getRootHosts());
                            }
                        }
                    }
                    // now add the remaining export rule
                    exportModify.addAll(arrayExportRuleMap.values());
                } else {
                    // if exportModify is null then create a new export rule and add
                    exportModify = new ArrayList<ExportRule>();
                    exportModify.addAll(arrayExportRuleMap.values());
                }
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            _logger.error("Not able to fetch latest Export rule from backend array.", e);
        }
        if (exportsToprocess == null) {
            exportsToprocess = new ArrayList<>();
        }
        _logger.info("Number of existng Rules found {}", exportsToprocess.size());
        // Process Exports
        for (ExportRule existingRule : exportsToprocess) {
            ArrayList<ExportRule> exps = existingExportsMapped.get(existingRule.getExportPath());
            if (exps == null) {
                exps = new ArrayList<>();
            }
            exps.add(existingRule);
            _logger.info("Checking existing export for {} : exps : {}", existingRule.getExportPath(), exps);
            existingExportsMapped.put(existingRule.getExportPath(), exps);
        }
        // Handle Add export Rules
        if (exportAdd != null && !exportAdd.isEmpty()) {
            // Check for existing exports for the export path including subdirectory
            ArrayList<ExportRule> exps = existingExportsMapped.get(exportPath);
            if (exps != null && !exps.isEmpty()) {
                _logger.error("Adding export rules is not supported as there can be only one export rule for VNXe.");
                ServiceError error = DeviceControllerErrors.vnxe.jobFailed("updateExportRules", "Adding export rule is not supported for VNXe");
                return BiosCommandResult.createErrorResult(error);
            }
        }
        // Handle Modified export Rules
        if (!exportsToprocess.isEmpty()) {
            if (subDir != null && !subDir.isEmpty()) {
                for (ExportRule existingRule : exportsToprocess) {
                    if (existingRule.getExportPath().endsWith("/" + subDir)) {
                        // Filter for a specific Sub Directory export
                        _logger.info("Updating all subdir exports rules at ViPR and  sub directory export at device {}", subDir);
                        processModifyRules(exportModify, existingRule, exportsToRemove, exportsToAdd);
                    } else {
                        exportsToRemove.add(existingRule);
                    }
                }
                // Handle Delete export Rules
                if (exportDelete != null && !exportDelete.isEmpty()) {
                    for (ExportRule existingRule : exportsToprocess) {
                        if (existingRule.getExportPath().endsWith("/" + subDir)) {
                            processDeleteRules(exportDelete, existingRule, exportsToRemove, newExportsForDelete);
                        } else {
                            exportsToRemove.add(existingRule);
                        }
                    }
                    exportsToAdd.addAll(newExportsForDelete);
                }
            } else {
                for (ExportRule existingRule : exportsToprocess) {
                    if (existingRule.getExportPath().equalsIgnoreCase(exportPath)) {
                        processModifyRules(exportModify, existingRule, exportsToRemove, exportsToAdd);
                    } else {
                        exportsToRemove.add(existingRule);
                    }
                }
                // Handle Delete export Rules
                if (exportDelete != null && !exportDelete.isEmpty()) {
                    for (ExportRule existingRule : exportsToprocess) {
                        if (existingRule.getExportPath().equalsIgnoreCase(exportPath)) {
                            processDeleteRules(exportDelete, existingRule, exportsToRemove, newExportsForDelete);
                        } else {
                            exportsToRemove.add(existingRule);
                        }
                    }
                    exportsToAdd.addAll(newExportsForDelete);
                }
            }
            // No of exports found to remove from the list
            _logger.info("No of exports found to remove from the existing exports list {}", exportsToRemove.size());
            exportsToprocess.removeAll(exportsToRemove);
            _logger.info("No of exports found to add to the existing exports list {}", exportsToAdd.size());
            exportsToprocess.addAll(exportsToAdd);
        } else {
            // This is valid only if no rules to modify exists
            if (exportAdd != null && !exportAdd.isEmpty()) {
                for (ExportRule newExport : exportAdd) {
                    if (args.getFileObjExports() != null) {
                        Collection<FileExport> expList = args.getFileObjExports().values();
                        Iterator<FileExport> it = expList.iterator();
                        FileExport exp = null;
                        while (it.hasNext()) {
                            FileExport export = it.next();
                            if (export.getPath().equalsIgnoreCase(exportPath)) {
                                exp = export;
                            }
                        }
                        if (exp != null) {
                            if (exp.getIsilonId() != null) {
                                newExport.setDeviceExportId(exp.getIsilonId());
                            }
                            if (exp.getNativeId() != null) {
                                newExport.setDeviceExportId(exp.getNativeId());
                            }
                        }
                    }
                    _logger.info("Add Export Rule {}", newExport);
                    newExport.setExportPath(exportPath);
                    exportsToAdd.add(newExport);
                }
            }
            exportsToprocess.addAll(exportsToAdd);
        }
        _logger.info("exportPath : {}", exportPath);
        args.setExportPath(exportPath);
        VNXeCommandJob job = null;
        for (ExportRule rule : exportsToprocess) {
            AccessEnum access = null;
            List<String> roHosts = null;
            List<String> rwHosts = null;
            List<String> rootHosts = null;
            String path = "/";
            String subdirName = "";
            String mountPathFs = args.getFsMountPath();
            String shareName = null;
            FileShareExport fsExport = null;
            boolean isDeleteRule = false;
            if (args.getFileObjExports() != null) {
                Collection<FileExport> expList = args.getFileObjExports().values();
                Iterator<FileExport> it = expList.iterator();
                FileExport exp = null;
                while (it.hasNext()) {
                    FileExport export = it.next();
                    if (export.getPath().equalsIgnoreCase(rule.getExportPath())) {
                        exp = export;
                    }
                }
                fsExport = new FileShareExport(exp);
            }
            String mountPathArg = rule.getExportPath();
            if (rule.getReadWriteHosts() != null && !rule.getReadWriteHosts().isEmpty()) {
                access = AccessEnum.READWRITE;
                if (rwHosts == null) {
                    rwHosts = new ArrayList<String>();
                }
                rwHosts.addAll(rule.getReadWriteHosts());
            }
            if (rule.getReadOnlyHosts() != null && !rule.getReadOnlyHosts().isEmpty()) {
                access = AccessEnum.READ;
                if (roHosts == null) {
                    roHosts = new ArrayList<String>();
                }
                roHosts.addAll(rule.getReadOnlyHosts());
            }
            if (rule.getRootHosts() != null && !rule.getRootHosts().isEmpty()) {
                access = AccessEnum.ROOT;
                if (rootHosts == null) {
                    rootHosts = new ArrayList<String>();
                }
                rootHosts.addAll(rule.getRootHosts());
            }
            if (newExportsForDelete.contains(rule)) {
                isDeleteRule = true;
            }
            if (args.getFileOperation()) {
                if (!mountPathArg.equals(mountPathFs)) {
                    // subdirectory specified.
                    subdirName = mountPathArg.substring(mountPathFs.length() + 1);
                    path += subdirName;
                }
                if (isDeleteRule) {
                    job = apiClient.removeNfsShare(rule.getDeviceExportId(), args.getFs().getNativeId());
                    if (job != null) {
                        completer = new VNXeFileTaskCompleter(FileShare.class, args.getFsId(), args.getOpId());
                        VNXeUnexportFileSystemJob unexportFSJob = new VNXeUnexportFileSystemJob(job.getId(), storage.getId(), completer, fsExport, args.getExportPath(), true);
                        ControllerServiceImpl.enqueueJob(new QueueJob(unexportFSJob));
                    } else {
                        _logger.error("No job returned from unexport FileSystem");
                        ServiceError error = DeviceControllerErrors.vnxe.jobFailed("UnExportFileSystem", "No Job returned from UnExportFileSystem");
                        return BiosCommandResult.createErrorResult(error);
                    }
                } else {
                    job = apiClient.exportFileSystem(args.getFs().getNativeId(), roHosts, rwHosts, rootHosts, access, path, null, rule.getDeviceExportId(), null);
                    if (job != null) {
                        completer = new VNXeFileTaskCompleter(FileShare.class, args.getFsId(), args.getOpId());
                        VNXeModifyExportJob modifyExportJob = new VNXeModifyExportJob(job.getId(), storage.getId(), completer, rule, fsExport, args.getExportPath(), args.getFileOperation(), isDeleteRule, shareName);
                        ControllerServiceImpl.enqueueJob(new QueueJob(modifyExportJob));
                    } else {
                        _logger.error("No job returned from updateExportRules");
                        ServiceError error = DeviceControllerErrors.vnxe.jobFailed("updateExportRules", "No Job returned from updateExportRules");
                        return BiosCommandResult.createErrorResult(error);
                    }
                }
            } else {
                shareName = VNXeUtils.buildNfsShareName(args.getSnapshotName(), path);
                if (isDeleteRule) {
                    job = apiClient.deleteNfsShareForSnapshot(rule.getDeviceExportId());
                    if (job != null) {
                        completer = new VNXeFileTaskCompleter(Snapshot.class, args.getSnapshotId(), args.getOpId());
                        VNXeUnexportFileSystemJob unexportFSJob = new VNXeUnexportFileSystemJob(job.getId(), storage.getId(), completer, fsExport, rule.getExportPath(), false);
                        ControllerServiceImpl.enqueueJob(new QueueJob(unexportFSJob));
                    } else {
                        _logger.error("No job returned from unexportFileSystem Snapshot");
                        ServiceError error = DeviceControllerErrors.vnxe.jobFailed("UnExportFileSystem", "No Job returned from UnExportFileSystem");
                        return BiosCommandResult.createErrorResult(error);
                    }
                } else {
                    job = apiClient.createNfsShareForSnap(args.getSnapNativeId(), roHosts, rwHosts, rootHosts, access, path, shareName, null);
                    if (job != null) {
                        completer = new VNXeFileTaskCompleter(Snapshot.class, args.getSnapshotId(), args.getOpId());
                        VNXeModifyExportJob modifyExportJob = new VNXeModifyExportJob(job.getId(), storage.getId(), completer, rule, fsExport, args.getExportPath(), args.getFileOperation(), isDeleteRule, shareName);
                        ControllerServiceImpl.enqueueJob(new QueueJob(modifyExportJob));
                    } else {
                        _logger.error("No job returned from updateExportRules");
                        ServiceError error = DeviceControllerErrors.vnxe.jobFailed("updateExportRules", "No Job returned from updateExportRules");
                        return BiosCommandResult.createErrorResult(error);
                    }
                }
            }
        }
    } catch (VNXeException e) {
        _logger.error("updateExportRules got the exception", e);
        if (completer != null) {
            completer.error(_dbClient, e);
        }
        return BiosCommandResult.createErrorResult(e);
    } catch (Exception ex) {
        _logger.error("updateExportRules got the exception", ex);
        ServiceError error = DeviceControllerErrors.vnxe.jobFailed("updateExportRules", ex.getMessage());
        if (completer != null) {
            completer.error(_dbClient, error);
        }
        return BiosCommandResult.createErrorResult(error);
    }
    _logger.info("UpdateExportRules job submitted");
    return BiosCommandResult.createPendingResult();
}

Example 27 with VNXeApiClient

use of com.emc.storageos.vnxe.VNXeApiClient in project coprhd-controller by CoprHD.

the class VNXeStorageDevice method doAddToConsistencyGroup.

@Override
public void doAddToConsistencyGroup(StorageSystem storage, URI consistencyGroupId, String replicationGroupName, List<URI> blockObjects, TaskCompleter taskCompleter) throws DeviceControllerException {
    BlockConsistencyGroup consistencyGroup = _dbClient.queryObject(BlockConsistencyGroup.class, consistencyGroupId);
    // check if lungroup has been created in the array
    String lunGroupId = consistencyGroup.getCgNameOnStorageSystem(storage.getId());
    if (lunGroupId == null || lunGroupId.isEmpty()) {
        // lun group has not created yet. return error
        _logger.error("The consistency group does not exist in the array: {}", storage.getSerialNumber());
        taskCompleter.error(_dbClient, DeviceControllerException.exceptions.consistencyGroupNotFound(consistencyGroup.getLabel(), consistencyGroup.getCgNameOnStorageSystem(storage.getId())));
        return;
    }
    VNXeApiClient apiClient = getVnxeClient(storage);
    try {
        List<String> luns = new ArrayList<String>();
        for (URI volume : blockObjects) {
            luns.add(volume.toString());
        }
        apiClient.addLunsToLunGroup(lunGroupId, luns);
        for (URI blockObjectURI : blockObjects) {
            BlockObject blockObject = BlockObject.fetch(_dbClient, blockObjectURI);
            if (blockObject != null) {
                blockObject.setConsistencyGroup(consistencyGroupId);
            }
            _dbClient.updateAndReindexObject(blockObject);
        }
        taskCompleter.ready(_dbClient);
        _logger.info("Added volumes to the consistency group successfully");
    } catch (Exception e) {
        _logger.error("Exception caught when adding volumes to the consistency group ", e);
        // Remove any references to the consistency group
        for (URI blockObjectURI : blockObjects) {
            BlockObject blockObject = BlockObject.fetch(_dbClient, blockObjectURI);
            if (blockObject != null) {
                blockObject.setConsistencyGroup(NullColumnValueGetter.getNullURI());
            }
            _dbClient.persistObject(blockObject);
        }
        taskCompleter.error(_dbClient, DeviceControllerException.exceptions.failedToAddMembersToConsistencyGroup(consistencyGroup.getLabel(), consistencyGroup.getCgNameOnStorageSystem(storage.getId()), e.getMessage()));
    }
}

Example 28 with VNXeApiClient

use of com.emc.storageos.vnxe.VNXeApiClient in project coprhd-controller by CoprHD.

the class VNXeStorageDevice method doDeleteSnapshot.

@Override
public BiosCommandResult doDeleteSnapshot(StorageSystem storage, FileDeviceInputOutput args) throws ControllerException {
    _logger.info("Deleting file system {} snapshot {} ", args.getFsName(), args.getSnapshotLabel());
    VNXeApiClient apiClient = getVnxeClient(storage);
    VNXeCommandJob job = null;
    VNXeFileTaskCompleter completer = null;
    try {
        job = apiClient.deleteFileSystemSnap(args.getSnapNativeId());
        if (job != null) {
            completer = new VNXeFileTaskCompleter(Snapshot.class, args.getSnapshotId(), args.getOpId());
            VNXeDeleteFileSystemSnapshotJob snapJob = new VNXeDeleteFileSystemSnapshotJob(job.getId(), storage.getId(), completer);
            ControllerServiceImpl.enqueueJob(new QueueJob(snapJob));
        } else {
            _logger.error("No job returned from deleteFileSystemSnap");
            ServiceError error = DeviceControllerErrors.vnxe.jobFailed("snapshotFileSystem", "No Job returned from deleteFileSystemSnap");
            return BiosCommandResult.createErrorResult(error);
        }
    } catch (VNXeException e) {
        _logger.error("Delete file system snapshot got the exception", e);
        if (completer != null) {
            completer.error(_dbClient, e);
        }
        return BiosCommandResult.createErrorResult(e);
    } catch (Exception ex) {
        _logger.error("Delete file system snpashot got the exception", ex);
        ServiceError error = DeviceControllerErrors.vnxe.jobFailed("DeleteFileSystemSnapshot", ex.getMessage());
        if (completer != null) {
            completer.error(_dbClient, error);
        }
        return BiosCommandResult.createErrorResult(error);
    }
    StringBuilder logMsgBuilder = new StringBuilder(String.format("Delete filesystem snapshot job submitted - Array:%s, fileSystem: %s, snapshot: %s", storage.getSerialNumber(), args.getFsName(), args.getSnapshotName()));
    _logger.info(logMsgBuilder.toString());
    return BiosCommandResult.createPendingResult();
}

Example 29 with VNXeApiClient

use of com.emc.storageos.vnxe.VNXeApiClient in project coprhd-controller by CoprHD.

the class VNXeUnManagedObjectDiscoverer method discoverUnManagedFileSystems.

public void discoverUnManagedFileSystems(AccessProfile accessProfile, DbClient dbClient, CoordinatorClient coordinator, PartitionManager partitionManager) throws Exception {
    log.info("Started discovery of UnManagedFilesystems for system {}", accessProfile.getSystemId());
    StorageSystem storageSystem = dbClient.queryObject(StorageSystem.class, accessProfile.getSystemId());
    VNXeApiClient apiClient = getVnxeClient(accessProfile);
    unManagedFilesystemsInsert = new ArrayList<UnManagedFileSystem>();
    unManagedFilesystemsUpdate = new ArrayList<UnManagedFileSystem>();
    List<VNXeFileSystem> filesystems = apiClient.getAllFileSystems();
    if (filesystems != null && !filesystems.isEmpty()) {
        Map<String, StoragePool> pools = getStoragePoolMap(storageSystem, dbClient);
        for (VNXeFileSystem fs : filesystems) {
            StoragePort storagePort = getStoragePortPool(storageSystem, dbClient, apiClient, fs);
            String fsNativeGuid = NativeGUIDGenerator.generateNativeGuid(storageSystem.getSystemType(), storageSystem.getSerialNumber(), fs.getId());
            StoragePool pool = getStoragePoolOfUnManagedObject(fs.getPool().getId(), storageSystem, pools);
            if (null == pool) {
                log.error("Skipping unmanaged volume discovery as the file system {} storage pool doesn't exist in ViPR", fs.getId());
                continue;
            }
            if (checkStorageFileSystemExistsInDB(fsNativeGuid, dbClient)) {
                log.info("Skipping file system {} as it is already managed by ViPR", fsNativeGuid);
                continue;
            }
            // Create UnManaged FS
            String fsUnManagedFsNativeGuid = NativeGUIDGenerator.generateNativeGuidForPreExistingFileSystem(storageSystem.getSystemType(), storageSystem.getSerialNumber().toUpperCase(), fs.getId());
            UnManagedFileSystem unManagedFs = checkUnManagedFileSystemExistsInDB(dbClient, fsUnManagedFsNativeGuid);
            unManagedFs = createUnManagedFileSystem(unManagedFs, fsUnManagedFsNativeGuid, storageSystem, pool, storagePort, fs, dbClient);
            unManagedFilesystemsReturnedFromProvider.add(unManagedFs.getId());
        }
        if (!unManagedFilesystemsInsert.isEmpty()) {
            // Add UnManagedFileSystem
            partitionManager.insertInBatches(unManagedFilesystemsInsert, Constants.DEFAULT_PARTITION_SIZE, dbClient, UNMANAGED_FILESYSTEM);
        }
        if (!unManagedFilesystemsUpdate.isEmpty()) {
            // Update UnManagedFilesystem
            partitionManager.updateAndReIndexInBatches(unManagedFilesystemsUpdate, Constants.DEFAULT_PARTITION_SIZE, dbClient, UNMANAGED_FILESYSTEM);
        }
        // Process those active unmanaged fs objects available in database but not in newly discovered items, to mark them inactive.
        performStorageUnManagedFSBookKeeping(storageSystem, dbClient, partitionManager);
    } else {
        log.info("There are no file systems found on the system: {}", storageSystem.getId());
    }
}

Example 30 with VNXeApiClient

use of com.emc.storageos.vnxe.VNXeApiClient in project coprhd-controller by CoprHD.

the class VNXeUnManagedObjectDiscoverer method discoverAllCifsShares.

public void discoverAllCifsShares(AccessProfile accessProfile, DbClient dbClient, PartitionManager partitionManager) {
    StorageSystem storageSystem = dbClient.queryObject(StorageSystem.class, accessProfile.getSystemId());
    VNXeApiClient apiClient = getVnxeClient(accessProfile);
    log.info("discoverAllCifsShares for storage system {} - start", storageSystem.getId());
    unManagedCifsAclInsert = new ArrayList<UnManagedCifsShareACL>();
    unManagedCifsAclUpdate = new ArrayList<UnManagedCifsShareACL>();
    List<VNXeCifsShare> cifsExports = apiClient.getAllCifsShares();
    for (VNXeCifsShare exp : cifsExports) {
        log.info("Discovered fS share {}", exp.toString());
        VNXeFileSystem fs = null;
        if (exp.getFilesystem() != null) {
            fs = apiClient.getFileSystemByFSId(exp.getFilesystem().getId());
            String fsNativeGuid = NativeGUIDGenerator.generateNativeGuid(storageSystem.getSystemType(), storageSystem.getSerialNumber(), fs.getId());
            try {
                if (checkStorageFileSystemExistsInDB(fsNativeGuid, dbClient)) {
                    log.info("Skipping file system {} as it is already managed by ViPR", fsNativeGuid);
                    continue;
                }
                // Create UnManaged FS
                String fsUnManagedFsNativeGuid = NativeGUIDGenerator.generateNativeGuidForPreExistingFileSystem(storageSystem.getSystemType(), storageSystem.getSerialNumber().toUpperCase(), fs.getId());
                UnManagedFileSystem unManagedFs = checkUnManagedFileSystemExistsInDB(dbClient, fsUnManagedFsNativeGuid);
                StoragePort storagePort = getStoragePortPool(storageSystem, dbClient, apiClient, fs);
                String mountPath = extractValueFromStringSet(SupportedFileSystemInformation.MOUNT_PATH.toString(), unManagedFs.getFileSystemInformation());
                String exportPath = exp.getPath();
                if (!exportPath.equalsIgnoreCase("/")) {
                    mountPath = mountPath + exportPath;
                }
                // String mountPoint = storagePort.getPortNetworkId() + ":" + mountPath;
                String mountPoint = "\\\\" + storagePort.getPortNetworkId() + "\\" + exp.getName();
                String cifsShareId = exp.getId();
                associateCifsExportWithUMFS(unManagedFs, mountPoint, exp, storagePort);
                List<UnManagedCifsShareACL> cifsACLs = applyCifsSecurityRules(unManagedFs, mountPoint, exp, storagePort);
                log.info("Number of export rules discovered for file system {} is {}", unManagedFs.getId() + ":" + unManagedFs.getLabel(), cifsACLs.size());
                for (UnManagedCifsShareACL cifsAcl : cifsACLs) {
                    log.info("Unmanaged File share acls : {}", cifsAcl);
                    String fsShareNativeId = cifsAcl.getFileSystemShareACLIndex();
                    log.info("UMFS Share ACL index {}", fsShareNativeId);
                    String fsUnManagedFileShareNativeGuid = NativeGUIDGenerator.generateNativeGuidForPreExistingFileShare(storageSystem, fsShareNativeId);
                    log.info("Native GUID {}", fsUnManagedFileShareNativeGuid);
                    cifsAcl.setNativeGuid(fsUnManagedFileShareNativeGuid);
                    // Check whether the CIFS share ACL was present in ViPR DB.
                    UnManagedCifsShareACL existingACL = checkUnManagedFsCifsACLExistsInDB(dbClient, cifsAcl.getNativeGuid());
                    if (existingACL == null) {
                        unManagedCifsAclInsert.add(cifsAcl);
                    } else {
                        unManagedCifsAclInsert.add(cifsAcl);
                        existingACL.setInactive(true);
                        unManagedCifsAclUpdate.add(existingACL);
                    }
                }
                // Persist the UMFS as it changed the SMB Share Map.
                unManagedFs.setHasShares(true);
                unManagedFs.putFileSystemCharacterstics(UnManagedFileSystem.SupportedFileSystemCharacterstics.IS_FILESYSTEM_EXPORTED.toString(), Boolean.TRUE.toString());
                dbClient.persistObject(unManagedFs);
            } catch (IOException e) {
                log.error("IOException occured in discoverAllCifsShares()", e);
            }
        }
    }
    if (!unManagedCifsAclInsert.isEmpty()) {
        // Add UnManagedFileSystem
        partitionManager.insertInBatches(unManagedCifsAclInsert, Constants.DEFAULT_PARTITION_SIZE, dbClient, UNMANAGED_CIFS_SHARE_ACL);
        unManagedCifsAclInsert.clear();
    }
    if (!unManagedCifsAclUpdate.isEmpty()) {
        // Update UnManagedFilesystem
        partitionManager.updateInBatches(unManagedCifsAclUpdate, Constants.DEFAULT_PARTITION_SIZE, dbClient, UNMANAGED_CIFS_SHARE_ACL);
        unManagedCifsAclUpdate.clear();
    }
}