AlarmManager.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.List;

  26. import org.openspcoop2.core.allarmi.Allarme;
  27. import org.openspcoop2.core.allarmi.AllarmeHistory;
  28. import org.openspcoop2.core.allarmi.AllarmeNotifica;
  29. import org.openspcoop2.core.allarmi.AllarmeParametro;
  30. import org.openspcoop2.core.allarmi.IdAllarme;
  31. import org.openspcoop2.core.allarmi.constants.StatoAllarme;
  32. import org.openspcoop2.core.allarmi.dao.IAllarmeHistoryService;
  33. import org.openspcoop2.core.allarmi.dao.IAllarmeNotificaService;
  34. import org.openspcoop2.core.allarmi.dao.IAllarmeService;
  35. import org.openspcoop2.core.allarmi.dao.IAllarmeServiceSearch;
  36. import org.openspcoop2.core.allarmi.dao.IServiceManager;
  37. import org.openspcoop2.core.allarmi.utils.AllarmiConverterUtils;
  38. import org.openspcoop2.core.allarmi.utils.ProjectInfo;
  39. import org.openspcoop2.core.commons.dao.DAOFactory;
  40. import org.openspcoop2.core.plugins.IdPlugin;
  41. import org.openspcoop2.core.plugins.Plugin;
  42. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  43. import org.openspcoop2.generic_project.exception.NotFoundException;
  44. import org.openspcoop2.generic_project.expression.IExpression;
  45. import org.openspcoop2.monitor.engine.constants.CostantiConfigurazione;
  46. import org.openspcoop2.monitor.engine.dynamic.DynamicFactory;
  47. import org.openspcoop2.monitor.engine.dynamic.IDynamicLoader;
  48. import org.openspcoop2.monitor.sdk.alarm.AlarmStatus;
  49. import org.openspcoop2.monitor.sdk.alarm.IAlarm;
  50. import org.openspcoop2.monitor.sdk.alarm.IAlarmLogger;
  51. import org.openspcoop2.monitor.sdk.constants.AlarmStateValues;
  52. import org.openspcoop2.monitor.sdk.exceptions.AlarmException;
  53. import org.openspcoop2.monitor.sdk.exceptions.AlarmNotifyException;
  54. import org.openspcoop2.monitor.sdk.parameters.Parameter;
  55. import org.openspcoop2.monitor.sdk.plugins.IAlarmProcessing;
  56. import org.openspcoop2.utils.UtilsMultiException;
  57. import org.openspcoop2.utils.date.DateManager;
  58. import org.openspcoop2.utils.mail.Mail;
  59. import org.openspcoop2.utils.mail.Sender;
  60. import org.openspcoop2.utils.mail.SenderFactory;
  61. import org.openspcoop2.utils.resources.ScriptInvoker;
  62. import org.slf4j.Logger;


  65. /**
  66.  * AlarmManager
  67.  *
  68.  * @author Poli Andrea (apoli@link.it)
  69.  * @author $Author$
  70.  * @version $Rev$, $Date$
  71.  */
  72. public class AlarmManager {


  75.     private static AlarmEngineConfig alarmEngineConfig; 
  76.     public static AlarmEngineConfig getAlarmEngineConfig() {
  77.         return AlarmManager.alarmEngineConfig;
  78.     }
  79.     public static void setAlarmEngineConfig(AlarmEngineConfig alarmEngineConfig) {
  80.         AlarmManager.alarmEngineConfig = alarmEngineConfig;
  81.     }

  83.     /**
  84.      * Ritorna i dati di un allarme con identificativo idAllarme
  85.      * 
  86.      * @param idAllarme
  87.      *            Identificativo dell'allarme
  88.      * @return Allarme
  89.      * @throws AlarmException
  90.      */
  91.     public static IAlarm getAlarm(String idAllarme,Logger log, DAOFactory daoFactory) throws AlarmException {

  93.         AlarmImpl alarm = null;
  94.         try {
  95.             IServiceManager pluginSM = (IServiceManager) daoFactory.getServiceManager(ProjectInfo.getInstance());
  96.             IAllarmeServiceSearch allarmeDAO = pluginSM.getAllarmeServiceSearch();

  98.             IExpression expr = allarmeDAO.newExpression();
  99.             expr.equals(Allarme.model().NOME, idAllarme);

  101.             Allarme allarme = null;
  102.             try{
  103.                 allarme = allarmeDAO.find(expr);
  104.             }catch(NotFoundException notFound){
  105.                 // ignore
  106.             }
  107.                 
  108.             if (allarme != null) {
  109.                 alarm = (AlarmImpl) getAlarm(allarme,log,daoFactory);
  110.             } else
  111.                 throw new AlarmException("Allarme -" + idAllarme
  112.                         + "- non esistente");

  114.         } catch (Exception e) {
  115.             log.error("AlarmManager.getAlarm(" + idAllarme
  116.                     + ") ha rilevato un errore: " + e.getMessage(), e);
  117.             throw new AlarmException(e.getMessage(),e);
  118.         }
  119.         return alarm;
  120.     }

  122.     /**
  123.      * Ritorna i dati di un allarme a partire da una configurazione Allarme
  124.      * 
  125.      * @param allarme
  126.      *            Configurazione dell'allarme
  127.      * @return Allarme
  128.      * @throws AlarmException
  129.      */
  130.     public static IAlarm getAlarm(Allarme allarme,Logger log, DAOFactory daoFactory)
  131.             throws AlarmException {
  132.         return _getAlarm(allarme, log, daoFactory, null);
  133.     }
  134.     public static IAlarm getAlarm(Allarme allarme,Logger log, DAOFactory daoFactory, org.openspcoop2.core.plugins.dao.IServiceManager pluginSM)
  135.             throws AlarmException {
  136.         return _getAlarm(allarme, log, daoFactory, pluginSM);
  137.     }
  138.     private static IAlarm _getAlarm(Allarme allarme,Logger log, DAOFactory daoFactory, org.openspcoop2.core.plugins.dao.IServiceManager pluginSM)
  139.             throws AlarmException {
  140.         
  141.         AlarmImpl alarm = null;
  142.         try {
  143.             if (allarme != null) {
  144.                 
  145.                 alarm = new AlarmImpl(allarme,log,daoFactory);
  146.                 AlarmStateValues statusValue = null;
  147.                 StatoAllarme statoAllarme = AllarmiConverterUtils.toStatoAllarme(allarme.getStato());
  148.                 switch (statoAllarme) {
  149.                 case OK:
  150.                     statusValue = AlarmStateValues.OK;
  151.                     break;
  152.                 case WARNING:
  153.                     statusValue = AlarmStateValues.WARNING;
  154.                     break;
  155.                 case ERROR:
  156.                     statusValue = AlarmStateValues.ERROR;
  157.                     break;
  158.                 }
  159.                 AlarmStatus alarmStatus = new AlarmStatus();
  160.                 alarmStatus.setStatus(statusValue);
  161.                 alarmStatus.setDetail(allarme.getDettaglioStato());
  162.                 alarm.setStatus(alarmStatus);
  163.                 
  164.                 if(pluginSM==null) {
  165.                     pluginSM = 
  166.                             (org.openspcoop2.core.plugins.dao.IServiceManager) 
  167.                             daoFactory.getServiceManager(org.openspcoop2.core.plugins.utils.ProjectInfo.getInstance());
  168.                 }
  169.                 TipoPlugin tipoPlugin = TipoPlugin.ALLARME;
  170.                 IdPlugin idPlugin = new IdPlugin();
  171.                 idPlugin.setTipoPlugin(tipoPlugin.getValue());
  172.                 idPlugin.setTipo(allarme.getTipo());
  173.                 Plugin plugin = pluginSM.getPluginServiceSearch().get(idPlugin);
  174.                 
  175.                 alarm.setPluginClassName(plugin.getClassName());
  176.                 
  177.                 IDynamicLoader cAllarme = DynamicFactory.getInstance().newDynamicLoader(tipoPlugin, allarme.getTipo(), plugin.getClassName(), log);
  178.                 IAlarmProcessing alarmProc = (IAlarmProcessing) cAllarme.newInstance();
  179.                 alarm.setManuallyUpdateState(alarmProc.isManuallyUpdateState());
  180.                 alarm.setManuallyAckCriteria(alarmProc.isManuallyAckCriteria());
  181.                 AlarmContext ctx = new AlarmContext(allarme, log, daoFactory);
  182.                 List<Parameter<?>> listParameters = alarmProc.getParameters(ctx);
  183.                 
  184.                 for (AllarmeParametro parametro : allarme.getAllarmeParametroList()) {
  185.                     for (Parameter<?> parameter : listParameters) {
  186.                         if(parameter.getId().equals(parametro.getIdParametro())){
  187.                             parameter.setValueAsString(parametro.getValore());
  188.                             break;
  189.                         }
  190.                     }
  191.                 }
  192.                 
  193.                 for (Parameter<?> parameter : listParameters) {
  194.                     alarm.addParameter(parameter);
  195.                 }
  196.                 
  197.             } else
  198.                 throw new AlarmException("Allarme non valido");

  200.         } catch (Exception e) {
  201.             log.error(
  202.                     "AlarmManager.getAlarm(" + (allarme!=null ? allarme.getNome() : "Alarm undefined")
  203.                             + ") ha rilevato un errore: " + e.getMessage(), e);
  204.             throw new AlarmException(e.getMessage(),e);
  205.         }
  206.         return alarm;
  207.     }
  208.     
  209.     protected static void changeStatus(AlarmStatus newStatoAllarme,IAlarm allarme,IServiceManager allarmiSM,String username,boolean statusChanged, 
  210.             List<AllarmeHistory> repositoryHistory) throws AlarmException {
  211.         try {
  212.             
  213.             Allarme oldConfig = allarme.getConfigAllarme();
  214.             
  215.             IAllarmeServiceSearch allarmeSearchDAO = allarmiSM
  216.                     .getAllarmeServiceSearch();
  217.             IAllarmeService allarmeDAO = allarmiSM
  218.                     .getAllarmeService();
  219.             IAllarmeHistoryService allarmeHistoryDAO = allarmiSM
  220.                     .getAllarmeHistoryService();

  222.             IExpression expr = allarmeSearchDAO.newExpression();
  223.             expr.equals(Allarme.model().NOME, allarme.getId());

  225.             Allarme confAllarme = allarmeSearchDAO.find(expr); // non mi posso fidare dell'allarme passato come parametro. Potrebbe essere cambiato nel frattempo

  227.             if (confAllarme != null) {
  228.                 
  229.                 // Se il tipo è AlarmStatusWithAck sto forzando la decisione dell'ack all'utente console
  230.                 boolean autoChangeAck = true;
  231.                 if(newStatoAllarme instanceof AlarmStatusWithAck){
  232.                     AlarmStatusWithAck withAck = (AlarmStatusWithAck) newStatoAllarme;
  233.                     if(withAck.isAck()){
  234.                         confAllarme.setAcknowledged(1);
  235.                         oldConfig.setAcknowledged(1);
  236.                     }
  237.                     else{
  238.                         confAllarme.setAcknowledged(0);
  239.                         oldConfig.setAcknowledged(0);
  240.                     }
  241.                     autoChangeAck = false;
  242.                 }
  243.                 
  244.                 if(statusChanged && confAllarme.getStato()!=null){
  245.                     confAllarme.setStatoPrecedente(confAllarme.getStato());
  246.                     oldConfig.setStatoPrecedente(confAllarme.getStato());
  247.                 }
  248.                 
  249.                 switch (newStatoAllarme.getStatus()) {
  250.                 case OK:
  251.                     confAllarme.setStato(AllarmiConverterUtils.toIntegerValue(StatoAllarme.OK));
  252.                     break;
  253.                 case WARNING:
  254.                     confAllarme.setStato(AllarmiConverterUtils.toIntegerValue(StatoAllarme.WARNING));
  255.                     break;
  256.                 default:
  257.                     confAllarme.setStato(AllarmiConverterUtils.toIntegerValue(StatoAllarme.ERROR));
  258.                     break;
  259.                 }
  260.                 oldConfig.setStato(confAllarme.getStato());
  261.                 
  262.                 confAllarme.setLasttimestampUpdate(DateManager.getDate());
  263.                 oldConfig.setLasttimestampUpdate(confAllarme.getLasttimestampUpdate());
  264.                 
  265.                 // Azzero acknoledgement in caso di cambio stato
  266.                 if(statusChanged){
  267.                     if(autoChangeAck){
  268.                         // lo stato è modificato
  269.                         confAllarme.setAcknowledged(0);
  270.                         oldConfig.setAcknowledged(0);
  271.                     }
  272.                     else{
  273.                         // se lo stato è rimasto lo stesso ma è cambiato il dettaglio, modificao l'acknoldegement ??
  274.     //                  if(newStatoAllarme.getDetail()!=null && !newStatoAllarme.getDetail().equals(confAllarme.getDettaglioStato())){
  275.     //                      confAllarme.setAcknowledged(0);
  276.     //                  }
  277.                     }
  278.                 }
  279.                 
  280.                 confAllarme.setDettaglioStato(newStatoAllarme.getDetail());
  281.                 oldConfig.setDettaglioStato(confAllarme.getDettaglioStato());
  282.                 
  283.                 IdAllarme idConfAllarme = new IdAllarme();

  285.                 idConfAllarme.setId(confAllarme.getId());
  286.                 idConfAllarme.setNome(confAllarme.getNome());
  287. //              idConfAllarme.setIdConfigurazioneServizioAzione(confAllarme
  288. //                      .getIdConfigurazioneServizioAzione());
  289.                 
  290.                 // Recupero stato dell'allarme dal db per evitare di far crescere all'infinito l'history dell'allarme per ogni check.
  291.                 Allarme allarmeImmagineDB = allarmeDAO.get(idConfAllarme);
  292.                 
  293.                 //System.out.println("UPDATE ALLARME");
  294.                 allarmeDAO.update(idConfAllarme, confAllarme);
  295.                 
  296.                 boolean checkHistory = false;
  297.                 if(repositoryHistory!=null) {
  298.                     checkHistory = true;
  299.                 }
  300.                 else {
  301.                     AlarmEngineConfig alarmEngineConfig = AlarmManager.getAlarmEngineConfig();
  302.                     checkHistory = alarmEngineConfig.isHistoryEnabled();
  303.                 }
  304.                 if(checkHistory) {

  306.                     boolean registraHistory = registraHistory(confAllarme, allarmeImmagineDB);
  307.                     //System.out.println("REGISTRO HISTORY ALLARME ? "+registraHistory);
  308.                     if(registraHistory){
  309.                         AllarmeHistory history = new AllarmeHistory();
  310.                         history.setEnabled(confAllarme.getEnabled());
  311.                         history.setAcknowledged(confAllarme.getAcknowledged());
  312.                         history.setDettaglioStato(confAllarme.getDettaglioStato());
  313.                         history.setStato(confAllarme.getStato());
  314.                         IdAllarme idAllarme = new IdAllarme();
  315.                         idAllarme.setNome(confAllarme.getNome());
  316.                         history.setIdAllarme(idAllarme);
  317.                         history.setUtente(username);    
  318.                         history.setTimestampUpdate(confAllarme.getLasttimestampUpdate());
  319.                         if(repositoryHistory!=null) {
  320.                             repositoryHistory.add(history);
  321.                         }
  322.                         else {
  323.                             allarmeHistoryDAO.create(history);
  324.                         }
  325.                         //System.out.println("REGISTRATO HISTORY ALLARME");
  326.                     }
  327.                     
  328.                 }
  329.                 
  330.             } else
  331.                 throw new AlarmException("Allarme -" + allarme.getId()
  332.                         + "- non esistente");
  333.             
  334.         } catch (Exception e) {
  335.             allarme.getLogger().error(
  336.                     "AlarmManager.changeStatus() ha rilevato un errore: "
  337.                             + e.getMessage(), e);
  338.             throw new AlarmException(e.getMessage(),e);
  339.         }
  340.     }
  341.     
  342.     private static boolean registraHistory(Allarme confAllarme, Allarme allarmeImmagineDB){
  343.         
  344.         if(confAllarme.getEnabled()!=null){
  345.             if(allarmeImmagineDB.getEnabled()==null){
  346.                 return true;
  347.             }
  348.             else if(allarmeImmagineDB.getEnabled()!=null && confAllarme.getEnabled()!=null && 
  349.                     (allarmeImmagineDB.getEnabled().intValue() != confAllarme.getEnabled().intValue())){
  350.                 return true;
  351.             }
  352.         }
  353.         else{
  354.             if(allarmeImmagineDB.getEnabled()!=null){
  355.                 return true;
  356.             }
  357.         }
  358.         
  359.         if(confAllarme.getAcknowledged()!=null){
  360.             if(allarmeImmagineDB.getAcknowledged()==null){
  361.                 return true;
  362.             }
  363.             else if(allarmeImmagineDB.getAcknowledged()!=null && confAllarme.getAcknowledged()!=null &&
  364.                     (allarmeImmagineDB.getAcknowledged().intValue() != confAllarme.getAcknowledged().intValue())){
  365.                 return true;
  366.             }
  367.         }
  368.         else{
  369.             if(allarmeImmagineDB.getAcknowledged()!=null){
  370.                 return true;
  371.             }
  372.         }
  373.         
  374. //      Bug Fix OPPT-753:
  375. //          Il Dettaglio non deve far parte della discriminante se salvare o meno nell'history dell'allarme poichè l'allarme ha cambiato stato.
  376. //      if(confAllarme.getDettaglioStato()!=null){
  377. //          if(allarmeImmagineDB.getDettaglioStato()==null){
  378. //              return true;
  379. //          }
  380. //          else if(!allarmeImmagineDB.getDettaglioStato().equals(confAllarme.getDettaglioStato())){
  381. //              return true;
  382. //          }
  383. //      }
  384. //      else{
  385. //          if(allarmeImmagineDB.getDettaglioStato()!=null){
  386. //              return true;
  387. //          }
  388. //      }
  389.         
  390.         if(confAllarme.getStato()!=null){
  391.             if(allarmeImmagineDB.getStato()==null){
  392.                 return true;
  393.             }
  394.             else if(!allarmeImmagineDB.getStato().equals(confAllarme.getStato())){
  395.                 return true;
  396.             }
  397.         }
  398.         else{
  399.             if(allarmeImmagineDB.getStato()!=null){
  400.                 return true;
  401.             }
  402.         }
  403.         
  404.         
  405.         return false;
  406.     }
  407.     
  408.     protected static void sendMail(Allarme configAllarme, IAlarmLogger alarmLog, List<String> logEvents) throws Exception{
  409.         
  410.         AlarmEngineConfig alarmEngineConfig = AlarmManager.getAlarmEngineConfig();
  411.         if(alarmEngineConfig==null){
  412.             throw new Exception("Configurazione Mail non fornita, utilizzare il metodo AlarmManager.setAlarmEngineConfig(...)");
  413.         }
  414.         
  415.         List<String> destinatari = new ArrayList<>();
  416.         if(configAllarme.getMail()!=null && configAllarme.getMail().getDestinatari()!=null){
  417.             String [] tmp = configAllarme.getMail().getDestinatari().split(",");
  418.             if(tmp!=null && tmp.length>0){
  419.                 for (int i = 0; i < tmp.length; i++) {
  420.                     destinatari.add(tmp[i].trim());
  421.                 }
  422.             }
  423.         }
  424.         
  425.         if(destinatari.size()>0){
  426.             
  427.             Sender sender = null;
  428.             if(alarmEngineConfig.getMailSenderType()==null){ 
  429.                 throw new Exception("Configurazione mail errata [Parametro 'SenderType' non definito]");
  430.             }
  431.             else{
  432.                 sender = SenderFactory.newSender(alarmEngineConfig.getMailSenderType(), alarmLog.getInternalLogger());
  433.             }
  434.             
  435.             if(alarmEngineConfig.getMailSenderConnectionTimeout()!=null){
  436.                 sender.setConnectionTimeout(alarmEngineConfig.getMailSenderConnectionTimeout());
  437.             }
  438.             if(alarmEngineConfig.getMailSenderReadTimeout()!=null){
  439.                 sender.setReadTimeout(alarmEngineConfig.getMailSenderReadTimeout());
  440.             }
  441.             
  442.             for (String destinatario : destinatari) {
  443.                 
  444.                 Mail mail = new Mail();
  445.             
  446.                 // agent
  447.                 mail.setUserAgent(alarmEngineConfig.getMailAgent());
  448.                 
  449.                 // from
  450.                 if(alarmEngineConfig.getMailFrom()==null){ 
  451.                     throw new Exception("Configurazione mail errata [Parametro 'From' non definito]");
  452.                 }
  453.                 else{
  454.                     mail.setFrom(alarmEngineConfig.getMailFrom());
  455.                 }
  456.                 
  457.                 // to
  458.                 mail.setTo(destinatario);
  459.                 
  460.                 // dati connessione
  461.                 if(alarmEngineConfig.getMailHost()==null){ 
  462.                     throw new Exception("Configurazione mail errata [Parametro 'Hostname' non definito]");
  463.                 }
  464.                 else{
  465.                     mail.setServerHost(alarmEngineConfig.getMailHost());
  466.                 }
  467.                 if(alarmEngineConfig.getMailPort()==null){ 
  468.                     throw new Exception("Configurazione mail errata [Parametro 'Port' non definito]");
  469.                 }
  470.                 else{
  471.                     mail.setServerPort(alarmEngineConfig.getMailPort());
  472.                 }
  473.                 if(alarmEngineConfig.getMailUsername()!=null){ 
  474.                     mail.setUsername(alarmEngineConfig.getMailUsername());
  475.                 }
  476.                 if(alarmEngineConfig.getMailPassword()!=null){ 
  477.                     mail.setPassword(alarmEngineConfig.getMailPassword());
  478.                 }
  479.                 
  480.                 // ssl
  481.                 mail.setSslConfig(alarmEngineConfig.getMailSSLConfig());
  482.                 mail.setStartTls(alarmEngineConfig.isMailStartTls());
  483.                 
  484.                 // subject
  485.                 String templateSubjectMail = null;
  486.                 if(configAllarme.getMail()!=null && configAllarme.getMail().getSubject()!=null) {
  487.                     templateSubjectMail = configAllarme.getMail().getSubject();
  488.                 }
  489.                 if(templateSubjectMail==null || "".equals(templateSubjectMail)){
  490.                     templateSubjectMail = alarmEngineConfig.getMailSubject();
  491.                     if(templateSubjectMail==null){ 
  492.                         throw new Exception("Configurazione mail errata [Parametro 'Subject' non definito]");
  493.                     }
  494.                 }
  495.                 mail.setSubject(replaceKeywordTemplate(templateSubjectMail, configAllarme, false));
  496.                 
  497.                 // body
  498.                 String templateBodyMail = null;
  499.                 if(configAllarme.getMail()!=null && configAllarme.getMail().getBody()!=null) {
  500.                     templateBodyMail = configAllarme.getMail().getBody();
  501.                 }
  502.                 if(templateBodyMail==null || "".equals(templateBodyMail)){
  503.                     templateBodyMail = alarmEngineConfig.getMailBody();
  504.                     if(templateBodyMail==null){ 
  505.                         throw new Exception("Configurazione mail errata [Parametro 'Body' non definito]");
  506.                     }
  507.                 }
  508.                 mail.getBody().setMessage(replaceKeywordTemplate(templateBodyMail, configAllarme, false));
  509.                 
  510.                 // send
  511.                 sender.send(mail, alarmEngineConfig.isMailDebug());
  512.                 
  513.                 if(alarmEngineConfig.isMailDebug()){
  514.                     logEvents.add("eMail per notifica stato ["+configAllarme.getStato()+"] inviata correttamente al destinatario ["+destinatario+"]");
  515.                 }
  516.                 
  517.             }
  518.             
  519.         }
  520.     }
  521.     
  522.     protected static void invokeScript(Allarme configAllarme, IAlarmLogger alarmLog, List<String> logEvents) throws Exception{
  523.         
  524.         AlarmEngineConfig alarmEngineConfig = AlarmManager.getAlarmEngineConfig();
  525.         if(alarmEngineConfig==null){
  526.             throw new Exception("Configurazione Script non fornita, utilizzare il metodo AlarmManager.setAlarmEngineConfig(...)");
  527.         }
  528.         
  529.         String path = null;
  530.         if(configAllarme.getScript()!=null) {
  531.             path = configAllarme.getScript().getCommand();
  532.         }
  533.         if(path==null || "".equals(path)){
  534.             path = alarmEngineConfig.getDefaultScriptPath();
  535.             if(path==null){ 
  536.                 throw new Exception("Configurazione script errata [Parametro 'Path' non definito]");
  537.             }
  538.         }
  539.         
  540.         String args = null;
  541.         if(configAllarme.getScript()!=null) {
  542.             args = configAllarme.getScript().getArgs();
  543.         }
  544.         if(args==null || "".equals(args)){
  545.             args = alarmEngineConfig.getDefaultScriptArgs();
  546.             if(args==null){ 
  547.                 throw new Exception("Configurazione script errata [Parametro 'Args' non definito]");
  548.             }
  549.         }
  550.         args = replaceKeywordTemplate(args, configAllarme, true);
  551.         
  552.         ScriptInvoker invoker = new ScriptInvoker(path);
  553.         
  554.         List<String> arguments = new ArrayList<>();
  555.         StringBuilder bfUtils = null;
  556.         if(args!=null && !"".equals(args)){
  557.             String [] tmp = args.trim().split(" ");
  558.             for (int i = 0; i < tmp.length; i++) {
  559.                 String s = tmp[i].trim();
  560.                 if(bfUtils == null){
  561.                     if(s.startsWith("\"")){
  562.                         if(s.endsWith("\"")){
  563.                             if(s.length()>2){
  564.                                 arguments.add(s.substring(1,s.length()-1));
  565.                             }
  566.                             else{
  567.                                 arguments.add(s); // caso speciale?
  568.                             }
  569.                         }
  570.                         else{
  571.                             bfUtils = new StringBuilder(s.substring(1));
  572.                         }
  573.                     }
  574.                     else{
  575.                         arguments.add(s);
  576.                     }
  577.                 }
  578.                 else{
  579.                     if(s.endsWith("\"")){
  580.                         bfUtils.append(" ").append(s.substring(0, (s.length()-1)));
  581.                         arguments.add(bfUtils.toString());
  582.                         bfUtils = null;
  583.                     }
  584.                     else{
  585.                         bfUtils.append(" ").append(s);
  586.                     }
  587.                 }
  588.             }
  589.         }
  590.         
  591.         if(arguments.size()>0)
  592.             invoker.run(arguments.toArray(new String[1]));
  593.         else{
  594.             invoker.run();
  595.         }
  596.         
  597.         String msg = "Invocazione script ["+path+"] (args: "+args+") ha ritornato un codice di uscita ["+invoker.getExitValue()+
  598.                 "]\nOutputStream: "+invoker.getOutputStream()+"\nErrorStream: "+invoker.getErrorStream();
  599.         if(invoker.getExitValue()!=0){
  600.             throw new Exception(msg);
  601.         }
  602.         else{
  603.             if(alarmEngineConfig.isScriptDebug()){
  604.                 logEvents.add(msg);
  605.             }
  606.         }
  607.         
  608.     }
  609.     
  610.     public static String replaceKeywordTemplate(String original, Allarme configAllarme, boolean script){
  611.         
  612.         String newS = original.replace(CostantiConfigurazione.ALARM_KEYWORD_TEMPLATE_NOME_ALLARME, configAllarme.getAlias());
  613.         
  614.         newS = newS.replace(CostantiConfigurazione.ALARM_KEYWORD_TEMPLATE_ID_ALLARME, configAllarme.getNome());
  615.         
  616.         StatoAllarme statoAllarme = AllarmiConverterUtils.toStatoAllarme(configAllarme.getStato());
  617.         switch ( statoAllarme ) {
  618.         case OK:
  619.             newS = newS.replace(CostantiConfigurazione.ALARM_KEYWORD_TEMPLATE_STATO_ALLARME, "Ok");
  620.             break;
  621.         case WARNING:
  622.             newS = newS.replace(CostantiConfigurazione.ALARM_KEYWORD_TEMPLATE_STATO_ALLARME, "Warning");
  623.             break;
  624.         case ERROR:
  625.             newS = newS.replace(CostantiConfigurazione.ALARM_KEYWORD_TEMPLATE_STATO_ALLARME, "Error");
  626.             break;
  627.         }
  628.         
  629.         String details = configAllarme.getDettaglioStato();
  630.         if(details==null){
  631.             details = "";
  632.         }
  633.         if(script){
  634.             newS = newS.replace(CostantiConfigurazione.ALARM_KEYWORD_TEMPLATE_DETTAGLIO_ALLARME,"\""+details+"\"");
  635.         }else{
  636.             newS = newS.replace(CostantiConfigurazione.ALARM_KEYWORD_TEMPLATE_DETTAGLIO_ALLARME,details);
  637.         }
  638.         return newS;
  639.     }

  641.     public static void notifyChangeStatus(AlarmEngineConfig alarmEngineConfig, Allarme allarme,
  642.             IAlarm alarm, String pluginClassName,String threadName,
  643.             AlarmLogger alarmLogger,
  644.             AlarmStatus oldStatus, AlarmStatus nuovoStatoAllarme,
  645.             boolean checkAcknowledState) throws AlarmException, AlarmNotifyException {
  646.         
  647.         boolean statusChanged = false;
  648.         String prefix = null;
  649.         try{
  650.             
  651.             // Cambio di stato effettivo ?
  652.             if(oldStatus==null || oldStatus.getStatus()==null){
  653.                 statusChanged = true;
  654.             }
  655.             else{
  656.                 statusChanged = !oldStatus.getStatus().equals(nuovoStatoAllarme.getStatus());
  657.             }
  658.             
  659.             // Gestione invocazione script, mail e notifiche a plugin
  660.             boolean statusWarningError = false;
  661.             if(nuovoStatoAllarme!=null) {
  662.                 statusWarningError = AlarmStateValues.WARNING.equals(nuovoStatoAllarme.getStatus()) || AlarmStateValues.ERROR.equals(nuovoStatoAllarme.getStatus());
  663.             }
  664.             if(!statusChanged && (!statusWarningError || !checkAcknowledState)){
  665.                 alarmLogger.debug("Cambio di stato non rilevato (old:"+oldStatus+" new:"+nuovoStatoAllarme+")");
  666.                 return;
  667.             }
  668.             
  669.             if(statusChanged) {
  670.                 prefix = "Cambio di stato rilevato (old:"+oldStatus+" new:"+nuovoStatoAllarme+"); ";
  671.             }
  672.             else {
  673.                 prefix = "Cambio di stato non rilevato; ";
  674.             }
  675.             
  676.         }catch(Exception e){
  677.             throw new AlarmException(e.getMessage(),e);
  678.         }
  679.         
  680.         boolean invokePlugin = statusChanged;
  681.         boolean sendMail = false;
  682.         boolean invokeScript = false;
  683.         try {
  684.             alarmLogger.debug(prefix+"lettura configurazione in corso ...");
  685.             
  686.             boolean mailCheckAcknowledgedStatus = alarmEngineConfig.isMailCheckAcknowledgedStatus();
  687.             boolean mailSendChangeStatusOk = alarmEngineConfig.isMailSendChangeStatusOk();
  688.             
  689.             boolean scriptCheckAcknowledgedStatus = alarmEngineConfig.isScriptCheckAcknowledgedStatus();
  690.             boolean scriptSendChangeStatusOk = alarmEngineConfig.isScriptSendChangeStatusOk();
  691.             
  692.             boolean acknowledged = (allarme.getAcknowledged()==null || allarme.getAcknowledged()==1);
  693.             
  694.             
  695.             alarmLogger.debug(prefix+"valutazione se è necessario una notifica di cambio stato per mail/script (acknowledged:"+acknowledged+") ...");
  696.             
  697.             alarmLogger.debug(prefix+"mail sendChangeStatusOk:"+mailSendChangeStatusOk+" checkAcknowledgedStatus:"+mailCheckAcknowledgedStatus+"");
  698.             alarmLogger.debug(prefix+"script sendChangeStatusOk:"+scriptSendChangeStatusOk+" checkAcknowledgedStatus:"+scriptCheckAcknowledgedStatus+"");
  699.             
  700.             if(nuovoStatoAllarme!=null) {
  701.                 
  702.                 if(AlarmStateValues.OK.equals(nuovoStatoAllarme.getStatus())){
  703.                     if(mailSendChangeStatusOk){
  704.                         // sia in ack mode che non in ack mode viene spedito da questo metodo.
  705.                         // tanto deve essere spedita solo la prima volta e non continuamente
  706.                         sendMail = (allarme.getMail()!=null &&
  707.                                 allarme.getMail().getInvia()!=null && 
  708.                                 allarme.getMail().getInvia()==1);
  709.                     }
  710.                     if(scriptSendChangeStatusOk){
  711.                         // sia in ack mode che non in ack mode viene spedito da questo metodo.
  712.                         // tanto deve essere spedita solo la prima volta e non continuamente
  713.                         invokeScript = (allarme.getScript()!=null &&
  714.                                 allarme.getScript().getInvoca()!=null && 
  715.                                 allarme.getScript().getInvoca()==1);
  716.                     }
  717.                     
  718.                 }
  719.                 
  720.                 
  721.                 else if(AlarmStateValues.WARNING.equals(nuovoStatoAllarme.getStatus())){
  722.                     
  723.                     if( (statusChanged) || (mailCheckAcknowledgedStatus && !acknowledged) ){
  724.                         // NOTA: per come è impostata la pddMonitor il warning esiste solo se è attivo anche l'alert
  725.                         sendMail = (
  726.                                     allarme.getMail()!=null && 
  727.                                     allarme.getMail().getInvia()!=null && 
  728.                                     allarme.getMail().getInvia()==1
  729.                                 ) 
  730.                                 && 
  731.                                 (
  732.                                     allarme.getMail()!=null &&
  733.                                     allarme.getMail().getInviaWarning()!=null && 
  734.                                     allarme.getMail().getInviaWarning()==1
  735.                                 );
  736.                     }
  737.                     if( (statusChanged) || (scriptCheckAcknowledgedStatus && !acknowledged) ){
  738.                         // NOTA: per come è impostata la pddMonitor il warning esiste solo se è attivo anche l'alert
  739.                         invokeScript = (
  740.                                     allarme.getScript()!=null &&
  741.                                     allarme.getScript().getInvoca()!=null && 
  742.                                     allarme.getScript().getInvoca()==1
  743.                                 ) 
  744.                                 &&
  745.                                 (
  746.                                     allarme.getScript()!=null && 
  747.                                     allarme.getScript().getInvocaWarning()!=null && 
  748.                                     allarme.getScript().getInvocaWarning()==1
  749.                                 );
  750.                     }
  751.                     
  752.                 }
  753.                 else if(AlarmStateValues.ERROR.equals(nuovoStatoAllarme.getStatus())){
  754.                     
  755.                     if( (statusChanged) || (mailCheckAcknowledgedStatus && !acknowledged) ){
  756.                         sendMail = allarme.getMail()!=null &&
  757.                                 allarme.getMail().getInvia()!=null && 
  758.                                 allarme.getMail().getInvia()==1; // note: Alert rappresenta l'invio della mail nel db e non veramente solo il livello error
  759.                     }
  760.                     if( (statusChanged) || (scriptCheckAcknowledgedStatus && !acknowledged) ){
  761.                         invokeScript = allarme.getScript()!=null &&
  762.                                 allarme.getScript().getInvoca()!=null && 
  763.                                 allarme.getScript().getInvoca()==1; // note: Alert rappresenta l'invio via script nel db e non veramente solo il livello error
  764.                     }
  765.                     
  766.                 }
  767.             }
  768.             
  769.         }catch(Exception e){
  770.             throw new AlarmException(e.getMessage(),e);
  771.         }
  772.         
  773.         List<Exception> listExceptions = new ArrayList<Exception>();
  774.         
  775.         // Notifico cambio di stato all'interfaccia 
  776.         String pluginInvocationError = null;
  777.         try {
  778.             if(invokePlugin) {
  779.                 alarmLogger.debug(prefix+"notifica plugin ...");
  780.                 IDynamicLoader cPlugin = DynamicFactory.getInstance().newDynamicLoader(TipoPlugin.ALLARME,allarme.getTipo(),pluginClassName, alarmLogger.getInternalLogger());
  781.                 IAlarmProcessing alarmProc = (IAlarmProcessing) cPlugin.newInstance();
  782.                 alarmProc.changeStatusNotify(alarm, oldStatus, nuovoStatoAllarme);
  783.                 alarmLogger.debug(prefix+"notifica plugin terminata");
  784.             }
  785.         } catch( Exception e) {
  786.             alarmLogger.error(prefix+"notifica plugin fallita: "+e.getMessage(),e);
  787.             pluginInvocationError = e.getMessage();
  788.             listExceptions.add(e);
  789.         }
  790.         
  791.         // Notifico cambio di stato via mail
  792.         String sendMailError = null;
  793.         try {
  794.             if(sendMail){
  795.                 alarmLogger.debug(prefix+"notifica mail ...");
  796.                 List<String> logEvents = new ArrayList<>();
  797.                 AlarmManager.sendMail(allarme, alarmLogger, logEvents);
  798.                 if(logEvents!=null && !logEvents.isEmpty()) {
  799.                     for (String logEvent : logEvents) {
  800.                         String prefixLog = AlarmLogger.buildPrefix(threadName,allarme.getAlias(),allarme.getNome());
  801.                         alarmLogger.debug(prefixLog+logEvent);
  802.                     }
  803.                 }
  804.                 alarmLogger.debug(prefix+"notifica mail completata");
  805.             }
  806.         }   
  807.         catch( Exception e) {
  808.             alarmLogger.error(prefix+"notifica mail fallita: "+e.getMessage(),e);
  809.             sendMailError = e.getMessage();
  810.             listExceptions.add(e);
  811.         }
  812.         
  813.         // Notifico cambio di stato via script
  814.         String scriptInvocationError = null;
  815.         try {
  816.             if(invokeScript){
  817.                 alarmLogger.debug(prefix+"notifica via script ...");
  818.                 List<String> logEvents = new ArrayList<>();
  819.                 AlarmManager.invokeScript(allarme, alarmLogger, logEvents);
  820.                 if(logEvents!=null && !logEvents.isEmpty()) {
  821.                     for (String logEvent : logEvents) {
  822.                         String prefixLog = AlarmLogger.buildPrefix(threadName,allarme.getAlias(),allarme.getNome());
  823.                         alarmLogger.debug(prefixLog+logEvent);
  824.                     }
  825.                 }
  826.                 alarmLogger.debug(prefix+"notifica via script completata");
  827.             }
  828.         }   
  829.         catch( Exception e) {
  830.             alarmLogger.error(prefix+"notifica via script fallita: "+e.getMessage(),e);
  831.             scriptInvocationError = e.getMessage();
  832.             listExceptions.add(e);
  833.         }
  834.         
  835.         if(!listExceptions.isEmpty()) {
  836.             AlarmNotifyException ane = null;
  837.             if(listExceptions.size()==1) {
  838.                 Exception e = listExceptions.get(0);
  839.                 ane = new AlarmNotifyException(e.getMessage(),e);
  840.             }
  841.             else {
  842.                 org.openspcoop2.utils.UtilsMultiException multi = new UtilsMultiException(listExceptions.toArray(new Exception[listExceptions.size()]));
  843.                 ane = new AlarmNotifyException("Notifiche di cambio stato fallite",multi);
  844.             }
  845.             ane.setPluginInvocationError(pluginInvocationError);
  846.             ane.setSendMailError(sendMailError);
  847.             ane.setScriptInvocationError(scriptInvocationError);
  848.             throw ane;
  849.         }
  850.     }
  851.     
  852.     protected static void registraNotifica(AlarmLogger alarmLogger, Allarme allarme, AlarmStatus oldStatoAllarme, AlarmStatus newStatoAllarme, AllarmeHistory repositoryHistory,
  853.             IServiceManager allarmiSM) throws AlarmException {
  854.         try {
  855.             IAllarmeNotificaService allarmeNotificaSearchDAO = allarmiSM
  856.                     .getAllarmeNotificaService();
  857.             
  858.             AllarmeNotifica notifica = new AllarmeNotifica();
  859.             
  860.             notifica.setDataNotifica(DateManager.getDate());
  861.             
  862.             IdAllarme idAllarme = allarmiSM.getAllarmeServiceSearch().convertToId(allarme);
  863.             notifica.setIdAllarme(idAllarme);
  864.             
  865.             notifica.setOldStato(AllarmiConverterUtils.toIntegerValue(StatoAllarme.valueOf(oldStatoAllarme.getStatus().name())));
  866.             notifica.setOldDettaglioStato(oldStatoAllarme.getDetail());
  867.             
  868.             notifica.setNuovoStato(AllarmiConverterUtils.toIntegerValue(StatoAllarme.valueOf(newStatoAllarme.getStatus().name())));
  869.             notifica.setNuovoDettaglioStato(newStatoAllarme.getDetail());
  870.             
  871.             if(repositoryHistory!=null) {
  872.                 org.openspcoop2.core.allarmi.utils.serializer.JaxbSerializer serializer = new org.openspcoop2.core.allarmi.utils.serializer.JaxbSerializer();
  873.                 notifica.setHistoryEntry(serializer.toString(repositoryHistory));
  874.             }
  875.             allarmeNotificaSearchDAO.create(notifica);
  876.             
  877.         } catch (Exception e) {
  878.             alarmLogger.error(
  879.                     "Registrazione notifica di cambio stato fallita: "
  880.                             + e.getMessage(), e);
  881.             throw new AlarmException(e.getMessage(),e);
  882.         }
  883.     }
  884. }
Created with JaCoCo 0.8.8.202204050719