allow repetition for custom alerts

Signed-off-by: Abhishek Kumar <[email protected]>

Author: shwstppr

api/src/main/java/org/apache/cloudstack/alert/AlertService.java

@@ -16,18 +16,15 @@
 // under the License.
 package org.apache.cloudstack.alert;
 
-import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Map;
 import java.util.Set;
 
 import com.cloud.capacity.Capacity;
 import com.cloud.exception.InvalidParameterValueException;
 
 public interface AlertService {
     public static class AlertType {
-        private static Set<AlertType> defaultAlertTypes = new HashSet<AlertType>();
-        private static Map<String, AlertType> allAlertTypesMap = new HashMap<>();
+        private static final Set<AlertType> defaultAlertTypes = new HashSet<>();
         private final String name;
         private final short type;
         private final boolean repetitionAllowed;
@@ -39,7 +36,6 @@ private AlertType(short type, String name, boolean isDefault, boolean repetition
             if (isDefault) {
                 defaultAlertTypes.add(this);
             }
-            allAlertTypesMap.put(name, this);
         }
 
         public static final AlertType ALERT_TYPE_MEMORY = new AlertType(Capacity.CAPACITY_TYPE_MEMORY, "ALERT.MEMORY", true, false);
@@ -120,10 +116,6 @@ public static AlertType generateAlert(short type, String name) {
                 return new AlertType(type, name, false, false);
             }
         }
-
-        public static AlertType getAlertTypeByName(String name) {
-            return allAlertTypesMap.get(name);
-        }
     }
 
     boolean generateAlert(AlertType alertType, long dataCenterId, Long podId, String msg);

server/src/main/java/com/cloud/alert/AlertManagerImpl.java

@@ -36,10 +36,6 @@
 import javax.mail.MessagingException;
 import javax.naming.ConfigurationException;
 
-import com.cloud.dc.DataCenter;
-import com.cloud.dc.Pod;
-import com.cloud.org.Cluster;
-
 import org.apache.cloudstack.backup.BackupManager;
 import org.apache.cloudstack.framework.config.ConfigDepot;
 import org.apache.cloudstack.framework.config.ConfigKey;
@@ -71,9 +67,11 @@
 import com.cloud.configuration.Config;
 import com.cloud.configuration.ConfigurationManager;
 import com.cloud.dc.ClusterVO;
+import com.cloud.dc.DataCenter;
 import com.cloud.dc.DataCenter.NetworkType;
 import com.cloud.dc.DataCenterVO;
 import com.cloud.dc.HostPodVO;
+import com.cloud.dc.Pod;
 import com.cloud.dc.Vlan.VlanType;
 import com.cloud.dc.dao.ClusterDao;
 import com.cloud.dc.dao.DataCenterDao;
@@ -87,6 +85,7 @@
 import com.cloud.host.dao.HostDao;
 import com.cloud.network.Ipv6Service;
 import com.cloud.network.dao.IPAddressDao;
+import com.cloud.org.Cluster;
 import com.cloud.org.Grouping.AllocationState;
 import com.cloud.resource.ResourceManager;
 import com.cloud.storage.StorageManager;
@@ -164,7 +163,7 @@ public class AlertManagerImpl extends ManagerBase implements AlertManager, Confi
     protected String[] recipients = null;
     protected String senderAddress = null;
 
-    private final List<AlertType> allowedRepetitiveAlertTypes = new ArrayList<>();
+    private final List<String> allowedRepetitiveAlertTypeNames = new ArrayList<>();
 
     public AlertManagerImpl() {
         _executor = Executors.newCachedThreadPool(new NamedThreadFactory("Email-Alerts-Sender"));
@@ -254,23 +253,21 @@ public boolean configure(String name, Map<String, Object> params) throws Configu
     }
 
     protected void setupRepetitiveAlertTypes() {
-        allowedRepetitiveAlertTypes.clear();
+        allowedRepetitiveAlertTypeNames.clear();
         String allowedRepetitiveAlertsStr = AllowedRepetitiveAlertTypes.value();
         logger.trace("Allowed repetitive alert types specified by {}: {} ", AllowedRepetitiveAlertTypes.key(),
                 allowedRepetitiveAlertsStr);
         if (StringUtils.isBlank(allowedRepetitiveAlertsStr)) {
             return;
         }
         String[] allowedRepetitiveAlertTypesArray = allowedRepetitiveAlertsStr.split(",");
-        for (String alertTypeName : allowedRepetitiveAlertTypesArray) {
-            AlertType type = AlertType.getAlertTypeByName(alertTypeName.trim());
-            if (type == null) {
-                logger.warn("Unknown alert type name: {}, skipping it.", alertTypeName);
+        for (String allowedTypeName : allowedRepetitiveAlertTypesArray) {
+            if (StringUtils.isBlank(allowedTypeName)) {
                 continue;
             }
-            allowedRepetitiveAlertTypes.add(type);
+            allowedRepetitiveAlertTypeNames.add(allowedTypeName.toLowerCase());
         }
-        logger.trace("{} alert types specified for repetitive alerts", allowedRepetitiveAlertTypes.size());
+        logger.trace("{} alert types specified for repetitive alerts", allowedRepetitiveAlertTypeNames.size());
     }
 
     @Override
@@ -868,7 +865,8 @@ public void sendAlert(AlertType alertType, DataCenter dataCenter, Pod pod, Clust
 
     @Nullable
     private AlertVO getAlertForTrivialAlertType(AlertType alertType, long dataCenterId, Long podId, Long clusterId) {
-        if (alertType.isRepetitionAllowed() || allowedRepetitiveAlertTypes.contains(alertType)) {
+        if (alertType.isRepetitionAllowed() || (StringUtils.isNotBlank(alertType.getName()) &&
+                allowedRepetitiveAlertTypeNames.contains(alertType.getName().toLowerCase()))) {
             return null;
         }
         return _alertDao.getLastAlert(alertType.getType(), dataCenterId, podId, clusterId);

server/src/test/java/com/cloud/alert/AlertManagerImplTest.java

@@ -30,7 +30,6 @@
 import javax.mail.MessagingException;
 import javax.naming.ConfigurationException;
 
-import org.apache.cloudstack.alert.AlertService;
 import org.apache.cloudstack.backup.BackupManager;
 import org.apache.cloudstack.framework.config.ConfigKey;
 import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
@@ -317,39 +316,41 @@ private void mockAllowedRepetitiveAlertTypesConfigKey(String value) {
 
     @Test
     public void setupRepetitiveAlertTypesParsesValidAlertTypesCorrectly() {
-        mockAllowedRepetitiveAlertTypesConfigKey("ALERT.CPU,ALERT.MEMORY");
+        mockAllowedRepetitiveAlertTypesConfigKey(AlertManager.AlertType.ALERT_TYPE_CPU.getName() + "," + AlertManager.AlertType.ALERT_TYPE_MEMORY.getName());
         alertManagerImplMock.setupRepetitiveAlertTypes();
-        List<AlertService.AlertType> expectedTypes = (List<AlertService.AlertType>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypes");
+        List<String> expectedTypes = (List<String>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypeNames");
         Assert.assertNotNull(expectedTypes);
         Assert.assertEquals(2, expectedTypes.size());
-        Assert.assertTrue(expectedTypes.contains(AlertManager.AlertType.ALERT_TYPE_CPU));
-        Assert.assertTrue(expectedTypes.contains(AlertManager.AlertType.ALERT_TYPE_MEMORY));
+        Assert.assertTrue(expectedTypes.contains(AlertManager.AlertType.ALERT_TYPE_CPU.getName().toLowerCase()));
+        Assert.assertTrue(expectedTypes.contains(AlertManager.AlertType.ALERT_TYPE_MEMORY.getName().toLowerCase()));
     }
 
     @Test
     public void setupRepetitiveAlertTypesHandlesEmptyConfigValue() {
         mockAllowedRepetitiveAlertTypesConfigKey("");
         alertManagerImplMock.setupRepetitiveAlertTypes();
-        List<AlertService.AlertType> expectedTypes = (List<AlertService.AlertType>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypes");
+        List<String> expectedTypes = (List<String>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypeNames");
         Assert.assertNotNull(expectedTypes);
         Assert.assertTrue(expectedTypes.isEmpty());
     }
 
     @Test
-    public void setupRepetitiveAlertTypesIgnoresUnknownAlertTypes() {
-        mockAllowedRepetitiveAlertTypesConfigKey("ALERT.CPU,UNKNOWN_ALERT_TYPE");
+    public void setupRepetitiveAlertTypesIgnoresCustomAlertTypes() {
+        String customAlertTypeName = "CUSTOM_ALERT_TYPE";
+        mockAllowedRepetitiveAlertTypesConfigKey(AlertManager.AlertType.ALERT_TYPE_CPU.getName() + "," + customAlertTypeName);
         alertManagerImplMock.setupRepetitiveAlertTypes();
-        List<AlertService.AlertType> expectedTypes = (List<AlertService.AlertType>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypes");
+        List<String> expectedTypes = (List<String>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypeNames");
         Assert.assertNotNull(expectedTypes);
-        Assert.assertEquals(1, expectedTypes.size());
-        Assert.assertTrue(expectedTypes.contains(AlertManager.AlertType.ALERT_TYPE_CPU));
+        Assert.assertEquals(2, expectedTypes.size());
+        Assert.assertTrue(expectedTypes.contains(AlertManager.AlertType.ALERT_TYPE_CPU.getName().toLowerCase()));
+        Assert.assertTrue(expectedTypes.contains(customAlertTypeName.toLowerCase()));
     }
 
     @Test
     public void setupRepetitiveAlertTypesHandlesNullConfigValue() {
         mockAllowedRepetitiveAlertTypesConfigKey(null);
         alertManagerImplMock.setupRepetitiveAlertTypes();
-        List<AlertService.AlertType> expectedTypes = (List<AlertService.AlertType>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypes");
+        List<String> expectedTypes = (List<String>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypeNames");
         Assert.assertNotNull(expectedTypes);
         Assert.assertTrue(expectedTypes.isEmpty());
     }