sdnr/wt/devicemanager/provider/src/main/java/org/onap/ccsdk/features/sdnr/wt/devicemanager/toggleAlarmFilter/NotificationDelayFilter.java

   1 /*******************************************************************************
   2  * ============LICENSE_START========================================================================
   3  * ONAP : ccsdk feature sdnr wt
   4  * =================================================================================================
   5  * Copyright (C) 2019 highstreet technologies GmbH Intellectual Property. All rights reserved.
   6  * =================================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   8  * in compliance with the License. You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software distributed under the License
  13  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  14  * or implied. See the License for the specific language governing permissions and limitations under
  15  * the License.
  16  * ============LICENSE_END==========================================================================
  17  ******************************************************************************/
  18 package org.onap.ccsdk.features.sdnr.wt.devicemanager.toggleAlarmFilter;
  19
  20 import java.util.Map.Entry;
  21 import java.util.concurrent.ConcurrentHashMap;
  22 import java.util.concurrent.Executors;
  23 import java.util.concurrent.ScheduledExecutorService;
  24 import java.util.concurrent.TimeUnit;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27
  28 public class NotificationDelayFilter<T> implements AutoCloseable {
  29
  30     private static final Logger LOG = LoggerFactory.getLogger(NotificationDelayFilter.class);
  31
  32     private final ConcurrentHashMap <String, NotificationWithServerTimeStamp<T>> problemItems;
  33 //    private final HashMap<String, NotificationWithServerTimeStamp<T>> nonProblemItems;
  34     private final NotificationDelayedListener<T> timeoutListener;
  35
  36     private static long delay;
  37     private static boolean enabled;
  38
  39     public static void setDelay(long l) {
  40         NotificationDelayFilter.delay = l;
  41     }
  42
  43     public static long getDelay() {
  44         return NotificationDelayFilter.delay;
  45     }
  46
  47     public static boolean isEnabled() {
  48         return NotificationDelayFilter.enabled;
  49     }
  50
  51     public static void setEnabled(boolean enabled) {
  52         NotificationDelayFilter.enabled = enabled;
  53     }
  54
  55     private final ScheduledExecutorService scheduler;
  56     private final Runnable timerRunner = () -> onTick();
  57
  58     private final String nodeName;
  59
  60     public NotificationDelayFilter(String nodeName, NotificationDelayedListener<T> timeoutListener) {
  61         this.nodeName = nodeName;
  62         this.timeoutListener = timeoutListener;
  63         this.problemItems = new ConcurrentHashMap <>();
  64         this.scheduler = Executors.newScheduledThreadPool(1);
  65         this.startTimer();
  66     }
  67
  68     /**
  69      * If process the notification
  70      * @return true if other processing is required, false if not
  71      */
  72     public boolean processNotification(boolean cleared, String problemName, T notificationXml) {
  73         // ToggleAlarmFilter functionality
  74         if (NotificationDelayFilter.isEnabled()) {
  75             if (cleared) {
  76                 clearAlarmNotification(problemName, notificationXml);
  77             } else {
  78                 pushAlarmNotification(problemName, notificationXml);
  79             }
  80             return false;
  81         } else {
  82             return true;
  83         }
  84         // end of ToggleAlarmFilter
  85     }
  86
  87     /**
  88      * Push notification with a specific severity (everything except non-alarmed)
  89      * @param problemName key
  90      * @param notification related notification
  91      */
  92     public void pushAlarmNotification(String problemName, T notification) {
  93         synchronized (problemItems) {
  94
  95             boolean cp = this.problemItems.containsKey(problemName);
  96             if (!cp) {
  97                 // no alarm in entries => create entry and push the alarm currently
  98                 NotificationWithServerTimeStamp<T> item = new NotificationWithServerTimeStamp<>(
  99                         notification);
 100                 LOG.debug("add event into list for node " + this.nodeName + " for alarm " + problemName + ": "
 101                         + item.toString());
 102                 this.problemItems.put(problemName, item);
 103                 if (this.timeoutListener != null) {
 104                     this.timeoutListener.onNotificationDelay(notification);
 105                 }
 106             } else {
 107                 LOG.debug("clear contra event for node " + this.nodeName + " for alarm " + problemName);
 108                 this.problemItems.get(problemName).clrContraEvent();
 109             }
 110
 111         }
 112     }
 113
 114     /**
 115      * Push notification with severity non-alarmed
 116      * @param problemName key
 117      * @param notification related notification
 118      */
 119     public void clearAlarmNotification(String problemName, T notification) {
 120         synchronized (problemItems) {
 121
 122             boolean cp = this.problemItems.containsKey(problemName);
 123             if (cp) {
 124                 LOG.debug("set contra event for alarm " + problemName);
 125                 this.problemItems.get(problemName).setContraEvent(notification);
 126             } else {
 127                 // not in list => push directly through
 128                 if (this.timeoutListener != null) {
 129                     this.timeoutListener.onNotificationDelay(notification);
 130                 }
 131             }
 132         }
 133     }
 134
 135     private void startTimer() {
 136         scheduler.scheduleAtFixedRate(timerRunner, 0, 1, TimeUnit.SECONDS);
 137     }
 138
 139     private void stopTimer() {
 140         scheduler.shutdown();
 141     }
 142
 143     /**
 144      * check for clearing item out of the list
 145      */
 146     private void onTick() {
 147         long now = System.currentTimeMillis();
 148         try {
 149
 150             synchronized (problemItems) {
 151
 152                 for (Entry<String, NotificationWithServerTimeStamp<T>> entry : problemItems
 153                         .entrySet()) {
 154                     NotificationWithServerTimeStamp<T> value = entry.getValue();
 155                     if (value.isStable(now)) {
 156                         // send contra Alarm if exists
 157                         if (value.getContraAlarmNotification() != null) {
 158                             if (this.timeoutListener != null) {
 159                                 this.timeoutListener.onNotificationDelay(value.getContraAlarmNotification());
 160                             }
 161                         }
 162                         problemItems.remove(entry.getKey());
 163                         LOG.debug("removing entry for "+this.nodeName+" for alarm " + entry.getKey());
 164                     } else {
 165                         LOG.trace("currently state is still unstable for alarm " + entry.getKey());
 166                     }
 167                 }
 168
 169             }
 170         } catch (Exception e) {
 171             //Prevent stopping the task
 172             LOG.warn("Exception during NotificationDelayFilter Task", e);
 173         }
 174     }
 175
 176     @Override
 177     public void close() throws Exception {
 178         this.stopTimer();
 179     }
 180
 181 }