Refactor code to choose aggregate, network interface and creating storage volume; Also, the corresponding UT changes - #89

plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/service/StorageStrategy.java:610

• getNetworkInterface wraps unexpected exceptions in a CloudRuntimeException but drops the original cause, which makes upstream error handling/debugging harder (especially since callers may rewrap again).

        } catch (CloudRuntimeException e) {
            throw e;
        } catch (Exception e) {
            logger.error("Exception while retrieving network interfaces: ", e);
            throw new CloudRuntimeException("Failed to retrieve network interfaces: " + e.getMessage());
        }

plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/service/StorageStrategy.java:233

• This refactor changes the public API by removing the previous overloads createStorageVolume(String, Long) and getNetworkInterface(); however, the repo still contains unit tests that call the old signatures (e.g. StorageStrategyTest and OntapPrimaryDatastoreLifecycleTest). As-is, this will fail compilation unless those tests are updated (or compatibility wrappers are added).

    public Aggregate chooseAggregate(Long size) {
        String svmName = storage.getSvmName();
        if (aggregates == null || aggregates.isEmpty()) {
            logger.error("No aggregates available to create volume on SVM " + svmName);
            throw new CloudRuntimeException("No aggregates available to create volume on SVM " + svmName);
        }
        if (size == null || size <= 0) {
            throw new CloudRuntimeException("Invalid volume size provided: " + size);

plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/service/StorageStrategy.java:564

• Potential NullPointerException: iface.getIp() is dereferenced without a null check (iface.getIp().getAddress()). If ONTAP returns an interface record without an IP object, this will NPE and abort LIF selection. Consider skipping records with missing IP/address before calling isIPv4Address(...).

            for (IpInterface iface : response.getRecords()) {
                if (!Boolean.TRUE.equals(iface.getEnabled()) || !OntapStorageConstants.LIF_STATE_UP.equals(iface.getState())) {
                    continue;
                }
                if (!isIPv4Address(iface.getIp().getAddress())) {
                    continue;

plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/lifecycle/OntapPrimaryDatastoreLifecycle.java:165

• processDataLifSelection(...) can send a storage alert when a LIF warning is present. With the new ordering, this alert may fire before FlexVol creation succeeds; if volume creation later fails, operators may see alerts for a pool that never got created. Consider splitting LIF validation (fail fast before volume creation) from alert emission (only after volume creation succeeds).

            Pair<String, String> lifResult;
            try {
                lifResult = storageStrategy.getNetworkInterface(aggregate);
            } catch (Exception e) {
                logger.error("Exception occurred while retrieving network interface for pool: " + storagePoolName, e);
                throw new CloudRuntimeException("Failed to retrieve Data LIF from ONTAP: " + e.getMessage(), e);
            }
            processDataLifSelection(lifResult, details, storagePoolName, zoneId, podId);

            logger.info("Creating ONTAP volume '" + storagePoolName + "' with size: " + capacityBytes + " bytes (" +

plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/service/StorageStrategy.java:224

• chooseAggregate() is documented and implemented to pick the online aggregate with the largest available block space, but connect(true) currently calls validateAndSelectAggregatesForVolumeCreation(...), which overwrites this.aggregates with List.of(aggr) on each match. That means chooseAggregate() will typically see only the last eligible aggregate rather than all candidates, so the “largest available” selection can be wrong depending on SVM aggregate ordering.

     * Selects the best aggregate for a volume of the given size from candidates populated by
     * {@link #connect(boolean)} with aggregate validation enabled.
     *
     * <p>Picks the online aggregate with the largest available block space that can fit
     * {@code size}. The returned aggregate includes node information for LIF affinity.</p>
     *
     * @param size requested volume size in bytes
     * @return the chosen aggregate detail response