log capacity alongwith host/storagaepool ids

Author: sudo87

engine/schema/src/main/java/com/cloud/capacity/dao/CapacityDao.java

@@ -64,5 +64,5 @@ List<SummedCapacity> listCapacitiesGroupedByLevelAndType(Integer capacityType, L
 
     float findClusterConsumption(Long clusterId, short capacityType, long computeRequested);
 
-    List<Long> orderHostsByFreeCapacity(Long zoneId, Long clusterId, short capacityType);
+    Pair<List<Long>, Map<Long, Double>> orderHostsByFreeCapacity(Long zoneId, Long clusterId, short capacityType);
 }

engine/schema/src/main/java/com/cloud/capacity/dao/CapacityDaoImpl.java

@@ -1028,10 +1028,11 @@ public Pair<List<Long>, Map<Long, Double>> orderClustersByAggregateCapacity(long
     }
 
     @Override
-    public List<Long> orderHostsByFreeCapacity(Long zoneId, Long clusterId, short capacityTypeForOrdering){
+    public Pair<List<Long>, Map<Long, Double>> orderHostsByFreeCapacity(Long zoneId, Long clusterId, short capacityTypeForOrdering){
          TransactionLegacy txn = TransactionLegacy.currentTxn();
          PreparedStatement pstmt = null;
-         List<Long> result = new ArrayList<Long>();
+         List<Long> result = new ArrayList<>();
+         Map<Long, Double> hostCapacityMap = new HashMap<>();
          StringBuilder sql = new StringBuilder(ORDER_HOSTS_BY_FREE_CAPACITY_PART1);
          if (zoneId != null) {
              sql.append(" AND data_center_id = ?");
@@ -1054,9 +1055,11 @@ public List<Long> orderHostsByFreeCapacity(Long zoneId, Long clusterId, short ca
 
              ResultSet rs = pstmt.executeQuery();
              while (rs.next()) {
-                 result.add(rs.getLong(1));
+                 Long hostId = rs.getLong(1);
+                 result.add(hostId);
+                 hostCapacityMap.put(hostId, rs.getDouble(2));
              }
-             return result;
+             return new Pair<>(result, hostCapacityMap);
          } catch (SQLException e) {
              throw new CloudRuntimeException("DB Exception on: " + sql, e);
          } catch (Throwable e) {

engine/storage/src/main/java/org/apache/cloudstack/storage/allocator/AbstractStoragePoolAllocator.java

@@ -57,17 +57,22 @@
 import javax.naming.ConfigurationException;
 import java.math.BigDecimal;
 import java.security.SecureRandom;
+import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 public abstract class AbstractStoragePoolAllocator extends AdapterBase implements StoragePoolAllocator {
 
     protected BigDecimal storageOverprovisioningFactor = new BigDecimal(1);
     protected long extraBytesPerVolume = 0;
+    static DecimalFormat decimalFormat = new DecimalFormat("#.##");
     @Inject protected DataStoreManager dataStoreMgr;
     @Inject protected PrimaryDataStoreDao storagePoolDao;
     @Inject protected VolumeDao volumeDao;
@@ -137,12 +142,16 @@ protected List<StoragePool> reorderPoolsByCapacity(DeploymentPlan plan, List<Sto
                 capacityType, storagePool.getName(), storagePool.getUuid(), storageType
         ));
 
-        List<Long> poolIdsByCapacity = capacityDao.orderHostsByFreeCapacity(zoneId, clusterId, capacityType);
+        Pair<List<Long>, Map<Long, Double>> result = capacityDao.orderHostsByFreeCapacity(zoneId, clusterId, capacityType);
+        List<Long> poolIdsByCapacity = result.first();
+        Map<Long, String> sortedHostByCapacity = result.second().entrySet()
+                .stream()
+                .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
+                .collect(Collectors.toMap(Map.Entry::getKey, entry -> decimalFormat.format(entry.getValue() * 100) + "%", (e1, e2) -> e1, LinkedHashMap::new));
+        logger.debug("List of pools in descending order of hostId: [{}] available capacity (percentage): {}",
+                poolIdsByCapacity, sortedHostByCapacity);
 
-        logger.debug(String.format("List of pools in descending order of available capacity [%s].", poolIdsByCapacity));
-
-
-      //now filter the given list of Pools by this ordered list
+        // now filter the given list of Pools by this ordered list
         Map<Long, StoragePool> poolMap = new HashMap<>();
         for (StoragePool pool : pools) {
             poolMap.put(pool.getId(), pool);

engine/storage/src/main/java/org/apache/cloudstack/storage/allocator/ZoneWideStoragePoolAllocator.java

@@ -18,12 +18,16 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Comparator;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 import javax.inject.Inject;
 
+import com.cloud.utils.Pair;
 import org.springframework.stereotype.Component;
 
 import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
@@ -122,9 +126,16 @@ protected List<StoragePool> reorderPoolsByCapacity(DeploymentPlan plan,
             return null;
         }
 
-        List<Long> poolIdsByCapacity = capacityDao.orderHostsByFreeCapacity(zoneId, null, capacityType);
+        Pair<List<Long>, Map<Long, Double>> result = capacityDao.orderHostsByFreeCapacity(zoneId, null, capacityType);
+        List<Long> poolIdsByCapacity = result.first();
+        Map<Long, String> sortedHostByCapacity = result.second().entrySet()
+                .stream()
+                .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
+                .collect(Collectors.toMap(Map.Entry::getKey, entry -> decimalFormat.format(entry.getValue() * 100) + "%",
+                        (e1, e2) -> e1, LinkedHashMap::new));
         if (logger.isDebugEnabled()) {
-            logger.debug("List of zone-wide storage pools in descending order of free capacity: "+ poolIdsByCapacity);
+            logger.debug("List of zone-wide storage pools: [{}] in descending order of free capacity (percentage): {}",
+                    poolIdsByCapacity, sortedHostByCapacity);
         }
 
       //now filter the given list of Pools by this ordered list

server/src/main/java/com/cloud/agent/manager/allocator/impl/FirstFitAllocator.java

@@ -16,11 +16,15 @@
 // under the License.
 package com.cloud.agent.manager.allocator.impl;
 
+import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 import javax.inject.Inject;
 import javax.naming.ConfigurationException;
@@ -98,6 +102,7 @@ public class FirstFitAllocator extends AdapterBase implements HostAllocator {
     UserVmDetailsDao _userVmDetailsDao;
 
     boolean _checkHvm = true;
+    static DecimalFormat decimalFormat = new DecimalFormat("#.##");
 
     @Override
     public List<Host> allocateTo(VirtualMachineProfile vmProfile, DeploymentPlan plan, Type type, ExcludeList avoid, int returnUpTo) {
@@ -373,9 +378,16 @@ private List<? extends Host> reorderHostsByCapacity(DeploymentPlan plan, List<?
         if("RAM".equalsIgnoreCase(capacityTypeToOrder)){
             capacityType = CapacityVO.CAPACITY_TYPE_MEMORY;
         }
-        List<Long> hostIdsByFreeCapacity = _capacityDao.orderHostsByFreeCapacity(zoneId, clusterId, capacityType);
+        Pair<List<Long>, Map<Long, Double>> result = _capacityDao.orderHostsByFreeCapacity(zoneId, clusterId, capacityType);
+        List<Long> hostIdsByFreeCapacity = result.first();
+        Map<Long, String> sortedHostByCapacity = result.second().entrySet()
+                .stream()
+                .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
+                .collect(Collectors.toMap(Map.Entry::getKey, entry -> decimalFormat.format(entry.getValue() * 100) + "%",
+                        (e1, e2) -> e1, LinkedHashMap::new));
         if (logger.isDebugEnabled()) {
-            logger.debug("List of hosts in descending order of free capacity in the cluster: "+ hostIdsByFreeCapacity);
+            logger.debug("List of hosts: [{}] in descending order of free capacity (percentage) in the cluster: {}",
+                    hostIdsByFreeCapacity, sortedHostByCapacity);
         }
 
         //now filter the given list of Hosts by this ordered list