AlarmLibrary.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.monitor.engine.alarm;

  23. import java.util.ArrayList;
  24. import java.util.Collections;
  25. import java.util.List;
  26. import java.util.Map;
  27. import java.util.concurrent.ConcurrentHashMap;

  29. import org.slf4j.Logger;
  30. import org.openspcoop2.core.allarmi.Allarme;
  31. import org.openspcoop2.core.allarmi.IdAllarme;
  32. import org.openspcoop2.core.allarmi.constants.TipoAllarme;
  33. import org.openspcoop2.core.allarmi.constants.TipoPeriodo;
  34. import org.openspcoop2.core.allarmi.dao.IAllarmeServiceSearch;
  35. import org.openspcoop2.core.allarmi.dao.IServiceManager;
  36. import org.openspcoop2.core.allarmi.utils.AllarmiConverterUtils;
  37. import org.openspcoop2.core.allarmi.utils.ProjectInfo;
  38. import org.openspcoop2.core.commons.dao.DAOFactory;
  39. import org.openspcoop2.generic_project.exception.ExpressionException;
  40. import org.openspcoop2.generic_project.exception.ExpressionNotImplementedException;
  41. import org.openspcoop2.generic_project.exception.MultipleResultException;
  42. import org.openspcoop2.generic_project.exception.NotFoundException;
  43. import org.openspcoop2.generic_project.exception.NotImplementedException;
  44. import org.openspcoop2.generic_project.exception.ServiceException;
  45. import org.openspcoop2.generic_project.expression.IExpression;
  46. import org.openspcoop2.generic_project.expression.IPaginatedExpression;
  47. import org.openspcoop2.monitor.sdk.alarm.IAlarm;
  48. import org.openspcoop2.monitor.sdk.constants.AlarmStateValues;
  49. import org.openspcoop2.monitor.sdk.exceptions.AlarmException;
  50. import org.openspcoop2.utils.Utilities;

  52. /**
  53.  * AlarmLibrary
  54.  *
  55.  * @author Poli Andrea (apoli@link.it)
  56.  * @author $Author$
  57.  * @version $Rev$, $Date$
  58.  */
  59. public class AlarmLibrary {

  61.     private IAllarmeServiceSearch allarmeSearchDAO;
  62.     private Logger log;
  63.     private AlarmEngineConfig alarmEngineConfig;
  64.     private DAOFactory daoFactory;
  65.     
  66.     private Map<String, AlarmThread> activeThreads = null;
  67.     
  68.     private String getMessageAlarmNotExists(String name) {
  69.         return "Alarm ["+name+"] not exists";
  70.     }
  71.     
  72.     public AlarmLibrary(DAOFactory daoFactory,Logger log,AlarmEngineConfig alarmEngineConfig) throws AlarmException{
  73.         try{
  74.             this.daoFactory = daoFactory;
  75.             IServiceManager pluginSM = (IServiceManager) this.daoFactory.getServiceManager(ProjectInfo.getInstance());
  76.             this.allarmeSearchDAO = pluginSM.getAllarmeServiceSearch();
  77.             this.log = log;
  78.             this.alarmEngineConfig = alarmEngineConfig;
  79.             AlarmManager.setAlarmEngineConfig(alarmEngineConfig);
  80.         }catch(Exception e){
  81.             throw new AlarmException(e.getMessage(),e);
  82.         }
  83.     }
  84.     
  85.     /* 
  86.      * Utiltiies per dormire
  87.      * NOTA: Devo dormire il tempo minimo configurabile per un allarme (un minuto).
  88.      **/
  89.     
  90.     public void sleep(){
  91.         for (int i = 0; i < 60; i++) {
  92.             Utilities.sleep(1000); // Devo dormire il tempo minimo configurabile per un allarme (un minuto).
  93.             if(this.stop){
  94.                 break;
  95.             }
  96.         }
  97.     }
  98.     
  99.     /* Utiltiies per stop threads */
  100.     
  101.     private boolean stop = false;
  102.     public void stop(){
  103.         if(this.activeThreads!=null && this.activeThreads.size()>0){
  104.             for (AlarmThread alarmThread : this.activeThreads.values()) {
  105.                 this.stopAlarm(alarmThread);
  106.             }
  107.         }
  108.         this.stop = true;
  109.         this.activeThreads = null;
  110.     }
  111.     public void stopAlarm(String name,boolean throwExceptionNotFound) throws AlarmException{
  112.         if(this.activeThreads!=null && this.activeThreads.size()>0 && this.activeThreads.containsKey(name)){
  113.             AlarmThread alarmThread = this.activeThreads.get(name);
  114.             this.stopAlarm(alarmThread);
  115.             this.activeThreads.remove(name);
  116.         }
  117.         else{
  118.             if(throwExceptionNotFound){
  119.                 throw new AlarmException(getMessageAlarmNotExists(name));
  120.             }
  121.         }
  122.     }
  123.     private void stopAlarm(AlarmThread alarmThread){
  124.         alarmThread.setStop(true);
  125.         int max = 10 * 60 * 5; // attendo 5 minuti
  126.         int offset = 0;
  127.         int increment = 100;
  128.         while(offset<max && !alarmThread.isTerminated()){
  129.             Utilities.sleep(increment);
  130.             offset = offset + increment;
  131.         }
  132.     }
  133.     
  134.     /* Utiltiies per start threads */
  135.         
  136.     private boolean stopLibrary = false;
  137.     public void setStopLibrary(boolean stopLibrary) {
  138.         this.stopLibrary = stopLibrary;
  139.     }

  141.     public void executeAlarms(boolean exitAfterExecution) throws AlarmException{
  142.         try{
  143.             this.activeThreads = this.getActiveAlarmThreads(this.allarmeSearchDAO, this.log);
  144.             if(this.activeThreads.size()>0){
  145.                 for (AlarmThread alarmThread : this.activeThreads.values()) {
  146.                     Thread t = new Thread(alarmThread);
  147.                     t.start();  
  148.                 }
  149.                 
  150.                 if(!exitAfterExecution){
  151.                     while (!this.stopLibrary){
  152.                         // non deve morire mai
  153.                         this.sleep();
  154.                     }
  155.                 }
  156.             }
  157.             else{
  158.                 this.log.warn("Non sono stati trovati allarmi");
  159.             }
  160.         }catch(Exception e){
  161.             throw new AlarmException(e.getMessage(),e);
  162.         }
  163.     }
  164.     
  165.     private Allarme getAlarmConf(String name) throws AlarmException {
  166.         Allarme conf = null;
  167.         try{
  168.             conf = this.getActiveAlarmThread(this.allarmeSearchDAO, name);
  169.         }catch(Exception e){
  170.             throw new AlarmException(e.getMessage(),e);
  171.         }
  172.         if(conf==null){
  173.             throw new AlarmException(getMessageAlarmNotExists(name));
  174.         }
  175.         return conf;
  176.     }
  177.     public void executeAlarm(String name) throws AlarmException{
  178.         try{
  179.             Allarme conf = getAlarmConf(name);
  180.             if(conf.getEnabled()==1 && TipoAllarme.ATTIVO.equals(conf.getTipoAllarme())){
  181.                 AlarmThread alarmThread = this.createAlarmThread(conf);
  182.                 if(alarmThread!=null){
  183.                     if(this.activeThreads==null) {
  184.                         this.activeThreads = new ConcurrentHashMap<>();
  185.                     }
  186.                     this.activeThreads.put(conf.getNome(),alarmThread);
  187.                     Thread t = new Thread(alarmThread);
  188.                     t.start();  
  189.                 }
  190.             }
  191.         }catch(Exception e){
  192.             throw new AlarmException(e.getMessage(),e);
  193.         }
  194.     }
  195.     
  196.     /* Utiltiies per refresh threads */
  197.     
  198.     public void forceNewCheckAlarm(String name) throws AlarmException{
  199.         try{
  200.             getAlarmConf(name); // verificare se eliminabile
  201.             AlarmThread alarmThread = this.activeThreads.get(name);
  202.             alarmThread.forceNewCheck();
  203.         }catch(Exception e){
  204.             throw new AlarmException(e.getMessage(),e);
  205.         }
  206.     }
  207.     
  208.     /* Utiltiies per update stato threads */
  209.     
  210.     public void updateStateAlarm(String name,AlarmStateValues alarmStatus) throws AlarmException{
  211.         try{
  212.             getAlarmConf(name); // verificare se eliminabile
  213.             AlarmThread alarmThread = this.activeThreads.get(name);
  214.             alarmThread.updateState(alarmStatus);
  215.         }catch(Exception e){
  216.             throw new AlarmException(e.getMessage(),e);
  217.         }
  218.     }
  219.     
  220.     public void updateAcknoledgement(String name,boolean acknoledgement) throws AlarmException{
  221.         try{
  222.             getAlarmConf(name); // verificare se eliminabile
  223.             AlarmThread alarmThread = this.activeThreads.get(name);
  224.             alarmThread.updateAcknowledged(acknoledgement);
  225.         }catch(Exception e){
  226.             throw new AlarmException(e.getMessage(),e);
  227.         }
  228.     }
  229.     
  230.     
  231.     /* Utiltiies per get image threads */
  232.     
  233.     public String getAlarmImage(String name) throws AlarmException{
  234.         if(this.activeThreads!=null && this.activeThreads.size()>0 && this.activeThreads.containsKey(name)){
  235.             AlarmThread alarmThread = this.activeThreads.get(name);
  236.             return alarmThread.getStatoAllarme();
  237.         }
  238.         else{
  239.             throw new AlarmException(getMessageAlarmNotExists(name));
  240.         }
  241.     }
  242.     
  243.     public String getAlarmsImages() {
  244.         if(this.activeThreads!=null && this.activeThreads.size()>0){
  245.             List<String> list = new ArrayList<>();
  246.             for (String idAllarme : this.activeThreads.keySet()) {
  247.                 list.add(idAllarme);
  248.             }
  249.             Collections.sort(list);
  250.             StringBuilder sb = new StringBuilder();
  251.             for (String idAllarme : list) {
  252.                 if(sb.length()>0) {
  253.                     sb.append("\n");
  254.                 }
  255.                 sb.append(idAllarme);
  256.             }
  257.             return sb.toString();
  258.         }
  259.         else{
  260.             return "";
  261.         }
  262.     }
  263.     
  264.     
  265.     
  266.     /* Utiltiies per exists threads */
  267.     
  268.     public boolean existsAlarm(String name) {
  269.         return this.activeThreads!=null && this.activeThreads.size()>0 && this.activeThreads.containsKey(name);
  270.     }
  271.     
  272.     
  273.     /* Utiltiies interne */
  274.     
  275.     private Map<String, AlarmThread> getActiveAlarmThreads(IAllarmeServiceSearch allarmeSearchDAO, Logger log) throws ServiceException, NotImplementedException, ExpressionNotImplementedException, ExpressionException {
  276.         
  277.         IExpression expr = allarmeSearchDAO.newExpression();
  278.         expr.and();
  279.         expr.notEquals(Allarme.model().ENABLED,
  280.                 Integer.valueOf(0));
  281.         expr.notEquals(Allarme.model().TIPO_ALLARME,
  282.                 TipoAllarme.PASSIVO);
  283.         /**expr.isNotNull(Allarme.model().CLASS_NAME);*/

  285.         IPaginatedExpression pagExpr = allarmeSearchDAO
  286.                 .toPaginatedExpression(expr);
  287.         
  288.         List<Allarme> list = allarmeSearchDAO.findAll(pagExpr);
  289.         Map<String, AlarmThread> listAlarmThread = new ConcurrentHashMap<>();
  290.         
  291.         for (Allarme confAllarme : list) {
  292.             try {
  293.                 AlarmThread alarmThread = createAlarmThread(confAllarme);
  294.                 if(alarmThread!=null){
  295.                     listAlarmThread.put(confAllarme.getNome(),alarmThread);
  296.                 }
  297.             }catch(Exception t) {
  298.                 log.error("Creazione allarme con id '"+confAllarme.getNome()+"' (alias: "+confAllarme.getAlias()+") non riuscita: "+t.getMessage(),t);
  299.             }
  300.         }
  301.         return listAlarmThread;
  302.     }
  303.     
  304.     private Allarme getActiveAlarmThread(IAllarmeServiceSearch allarmeSearchDAO, String name) throws ServiceException, NotFoundException, MultipleResultException, NotImplementedException {
  305.         
  306.         IdAllarme id = new IdAllarme();
  307.         id.setNome(name);
  308.         return allarmeSearchDAO.get(id);
  309.         
  310.     }
  311.     
  312.     private AlarmThread createAlarmThread(Allarme confAllarme) throws AlarmException{
  313.         IAlarm alarm = AlarmManager.getAlarm(confAllarme,this.log,this.daoFactory);
  314.         String classname = ((AlarmImpl) alarm).getPluginClassName();
  315.         TipoPeriodo tipoPeriodo = AllarmiConverterUtils.toTipoPeriodo(confAllarme.getTipoPeriodo());
  316.         int periodo = confAllarme.getPeriodo().intValue();

  318.         AlarmThread alarmThread = null;
  319.         /**if (alarm != null) {*/
  320.         try {
  321.             alarmThread = new AlarmThread(this.log, confAllarme.getTipo(), classname, alarm, this.alarmEngineConfig);
  322.             if (periodo != 0) {
  323.                 switch (tipoPeriodo) {
  324.                 case G:
  325.                     alarmThread.setPeriodByDays(periodo);
  326.                     break;
  327.                 case H:
  328.                     alarmThread.setPeriodByHours(periodo);
  329.                     break;
  330.                 case M:
  331.                     alarmThread.setPeriodByMinutes(periodo);
  332.                     break;
  333.                 default:
  334.                     alarmThread.setPeriodBySeconds(periodo);
  335.                     break;
  336.                 }
  337.             }
  338.             
  339.         } catch (AlarmException e) {
  340.             this.log.error(e.getMessage(),e);
  341.         }
  342.         return alarmThread;
  343.     }
  344.         
  345. }
Created with JaCoCo 0.8.8.202204050719