Alarm Result State

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.rule.engine.profile;
+
+public enum AlarmEvalResult {
+
+    FALSE, NOT_YET_TRUE, TRUE;
+
+}

@@ -123,17 +123,17 @@ class AlarmRuleState {
         }
         }
     }
     }
 
 
-    public boolean eval(DataSnapshot data) {
+    public AlarmEvalResult eval(DataSnapshot data) {
         boolean active = isActive(data.getTs());
         boolean active = isActive(data.getTs());
         switch (spec.getType()) {
         switch (spec.getType()) {
             case SIMPLE:
             case SIMPLE:
-                return active && eval(alarmRule.getCondition(), data);
+                return (active && eval(alarmRule.getCondition(), data)) ? AlarmEvalResult.TRUE : AlarmEvalResult.FALSE;
             case DURATION:
             case DURATION:
                 return evalDuration(data, active);
                 return evalDuration(data, active);
             case REPEATING:
             case REPEATING:
                 return evalRepeating(data, active);
                 return evalRepeating(data, active);
             default:
             default:
-                return false;
+                return AlarmEvalResult.FALSE;
         }
         }
     }
     }
 
 
@@ -203,17 +203,17 @@ class AlarmRuleState {
         }
         }
     }
     }
 
 
-    private boolean evalRepeating(DataSnapshot data, boolean active) {
+    private AlarmEvalResult evalRepeating(DataSnapshot data, boolean active) {
         if (active && eval(alarmRule.getCondition(), data)) {
         if (active && eval(alarmRule.getCondition(), data)) {
             state.setEventCount(state.getEventCount() + 1);
             state.setEventCount(state.getEventCount() + 1);
             updateFlag = true;
             updateFlag = true;
-            return state.getEventCount() >= requiredRepeats;
+            return state.getEventCount() >= requiredRepeats ? AlarmEvalResult.TRUE : AlarmEvalResult.NOT_YET_TRUE;
         } else {
         } else {
-            return false;
+            return AlarmEvalResult.FALSE;
         }
         }
     }
     }
 
 
-    private boolean evalDuration(DataSnapshot data, boolean active) {
+    private AlarmEvalResult evalDuration(DataSnapshot data, boolean active) {
         if (active && eval(alarmRule.getCondition(), data)) {
         if (active && eval(alarmRule.getCondition(), data)) {
             if (state.getLastEventTs() > 0) {
             if (state.getLastEventTs() > 0) {
                 if (data.getTs() > state.getLastEventTs()) {
                 if (data.getTs() > state.getLastEventTs()) {
@@ -226,24 +226,28 @@ class AlarmRuleState {
                 state.setDuration(0L);
                 state.setDuration(0L);
                 updateFlag = true;
                 updateFlag = true;
             }
             }
-            return state.getDuration() > requiredDurationInMs;
+            return state.getDuration() > requiredDurationInMs ? AlarmEvalResult.TRUE : AlarmEvalResult.NOT_YET_TRUE;
         } else {
         } else {
-            return false;
+            return AlarmEvalResult.FALSE;
         }
         }
     }
     }
 
 
-    public boolean eval(long ts) {
+    public AlarmEvalResult eval(long ts) {
         switch (spec.getType()) {
         switch (spec.getType()) {
             case SIMPLE:
             case SIMPLE:
             case REPEATING:
             case REPEATING:
-                return false;
+                return AlarmEvalResult.NOT_YET_TRUE;
             case DURATION:
             case DURATION:
                 if (requiredDurationInMs > 0 && state.getLastEventTs() > 0 && ts > state.getLastEventTs()) {
                 if (requiredDurationInMs > 0 && state.getLastEventTs() > 0 && ts > state.getLastEventTs()) {
                     long duration = state.getDuration() + (ts - state.getLastEventTs());
                     long duration = state.getDuration() + (ts - state.getLastEventTs());
-                    return duration > requiredDurationInMs && isActive(ts);
+                    if (isActive(ts)) {
+                        return duration > requiredDurationInMs ? AlarmEvalResult.TRUE : AlarmEvalResult.NOT_YET_TRUE;
+                    } else {
+                        return AlarmEvalResult.FALSE;
+                    }
                 }
                 }
             default:
             default:
-                return false;
+                return AlarmEvalResult.FALSE;
         }
         }
     }
     }
 
 

@@ -72,7 +72,7 @@ class AlarmState {
         return createOrClearAlarms(ctx, ts, null, AlarmRuleState::eval);
         return createOrClearAlarms(ctx, ts, null, AlarmRuleState::eval);
     }
     }
 
 
-    public <T> boolean createOrClearAlarms(TbContext ctx, T data, SnapshotUpdate update, BiFunction<AlarmRuleState, T, Boolean> evalFunction) {
+    public <T> boolean createOrClearAlarms(TbContext ctx, T data, SnapshotUpdate update, BiFunction<AlarmRuleState, T, AlarmEvalResult> evalFunction) {
         boolean stateUpdate = false;
         boolean stateUpdate = false;
         AlarmSeverity resultSeverity = null;
         AlarmSeverity resultSeverity = null;
         log.debug("[{}] processing update: {}", alarmDefinition.getId(), data);
         log.debug("[{}] processing update: {}", alarmDefinition.getId(), data);
@@ -81,22 +81,28 @@ class AlarmState {
                 log.debug("[{}][{}] Update is not valid for current rule state", alarmDefinition.getId(), state.getSeverity());
                 log.debug("[{}][{}] Update is not valid for current rule state", alarmDefinition.getId(), state.getSeverity());
                 continue;
                 continue;
             }
             }
-            boolean evalResult = evalFunction.apply(state, data);
+            AlarmEvalResult evalResult = evalFunction.apply(state, data);
             stateUpdate |= state.checkUpdate();
             stateUpdate |= state.checkUpdate();
-            if (evalResult) {
+            if (AlarmEvalResult.TRUE.equals(evalResult)) {
                 resultSeverity = state.getSeverity();
                 resultSeverity = state.getSeverity();
                 break;
                 break;
+            } else if (AlarmEvalResult.FALSE.equals(evalResult)) {
+                state.clear();
+                stateUpdate |= state.checkUpdate();
             }
             }
         }
         }
         if (resultSeverity != null) {
         if (resultSeverity != null) {
-            pushMsg(ctx, calculateAlarmResult(ctx, resultSeverity));
+            TbAlarmResult result = calculateAlarmResult(ctx, resultSeverity);
+            if (result != null) {
+                pushMsg(ctx, result);
+            }
         } else if (currentAlarm != null && clearState != null) {
         } else if (currentAlarm != null && clearState != null) {
             if (!validateUpdate(update, clearState)) {
             if (!validateUpdate(update, clearState)) {
                 log.debug("[{}] Update is not valid for current clear state", alarmDefinition.getId());
                 log.debug("[{}] Update is not valid for current clear state", alarmDefinition.getId());
                 return stateUpdate;
                 return stateUpdate;
             }
             }
-            Boolean evalResult = evalFunction.apply(clearState, data);
-            if (evalResult) {
+            AlarmEvalResult evalResult = evalFunction.apply(clearState, data);
+            if (AlarmEvalResult.TRUE.equals(evalResult)) {
                 stateUpdate |= clearState.checkUpdate();
                 stateUpdate |= clearState.checkUpdate();
                 for (AlarmRuleState state : createRulesSortedBySeverityDesc) {
                 for (AlarmRuleState state : createRulesSortedBySeverityDesc) {
                     state.clear();
                     state.clear();
@@ -105,6 +111,9 @@ class AlarmState {
                 ctx.getAlarmService().clearAlarm(ctx.getTenantId(), currentAlarm.getId(), JacksonUtil.OBJECT_MAPPER.createObjectNode(), System.currentTimeMillis());
                 ctx.getAlarmService().clearAlarm(ctx.getTenantId(), currentAlarm.getId(), JacksonUtil.OBJECT_MAPPER.createObjectNode(), System.currentTimeMillis());
                 pushMsg(ctx, new TbAlarmResult(false, false, true, currentAlarm));
                 pushMsg(ctx, new TbAlarmResult(false, false, true, currentAlarm));
                 currentAlarm = null;
                 currentAlarm = null;
+            } else if (AlarmEvalResult.FALSE.equals(evalResult)) {
+                clearState.clear();
+                stateUpdate |= clearState.checkUpdate();
             }
             }
         }
         }
         return stateUpdate;
         return stateUpdate;
@@ -183,13 +192,18 @@ class AlarmState {
             // Maybe we should fetch alarm every time?
             // Maybe we should fetch alarm every time?
             currentAlarm.setEndTs(System.currentTimeMillis());
             currentAlarm.setEndTs(System.currentTimeMillis());
             AlarmSeverity oldSeverity = currentAlarm.getSeverity();
             AlarmSeverity oldSeverity = currentAlarm.getSeverity();
-            if (!oldSeverity.equals(severity)) {
-                currentAlarm.setSeverity(severity);
-                currentAlarm = ctx.getAlarmService().createOrUpdateAlarm(currentAlarm);
-                return new TbAlarmResult(false, false, true, false, currentAlarm);
+            // Skip update if severity is decreased.
+            if (severity.ordinal() <= oldSeverity.ordinal()) {
+                if (!oldSeverity.equals(severity)) {
+                    currentAlarm.setSeverity(severity);
+                    currentAlarm = ctx.getAlarmService().createOrUpdateAlarm(currentAlarm);
+                    return new TbAlarmResult(false, false, true, false, currentAlarm);
+                } else {
+                    currentAlarm = ctx.getAlarmService().createOrUpdateAlarm(currentAlarm);
+                    return new TbAlarmResult(false, true, false, false, currentAlarm);
+                }
             } else {
             } else {
-                currentAlarm = ctx.getAlarmService().createOrUpdateAlarm(currentAlarm);
-                return new TbAlarmResult(false, true, false, false, currentAlarm);
+                return null;
             }
             }
         } else {
         } else {
             currentAlarm = new Alarm();
             currentAlarm = new Alarm();

@@ -167,14 +167,14 @@ public class TbDeviceProfileNode implements TbNode {
     protected void updateProfile(TbContext ctx, DeviceProfileId deviceProfileId) throws ExecutionException, InterruptedException {
     protected void updateProfile(TbContext ctx, DeviceProfileId deviceProfileId) throws ExecutionException, InterruptedException {
         DeviceProfile deviceProfile = cache.get(ctx.getTenantId(), deviceProfileId);
         DeviceProfile deviceProfile = cache.get(ctx.getTenantId(), deviceProfileId);
         if (deviceProfile != null) {
         if (deviceProfile != null) {
-            log.info("[{}] Received device profile update notification: {}", ctx.getSelfId(), deviceProfile);
+            log.debug("[{}] Received device profile update notification: {}", ctx.getSelfId(), deviceProfile);
             for (DeviceState state : deviceStates.values()) {
             for (DeviceState state : deviceStates.values()) {
                 if (deviceProfile.getId().equals(state.getProfileId())) {
                 if (deviceProfile.getId().equals(state.getProfileId())) {
                     state.updateProfile(ctx, deviceProfile);
                     state.updateProfile(ctx, deviceProfile);
                 }
                 }
             }
             }
         } else {
         } else {
-            log.info("[{}] Received stale profile update notification: [{}]", ctx.getSelfId(), deviceProfileId);
+            log.debug("[{}] Received stale profile update notification: [{}]", ctx.getSelfId(), deviceProfileId);
         }
         }
     }
     }