AlarmThread.java

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

package org.openspcoop2.monitor.engine.alarm;

import org.openspcoop2.core.allarmi.constants.StatoAllarme;
import org.openspcoop2.core.allarmi.utils.AllarmiConverterUtils;
import org.openspcoop2.core.plugins.constants.TipoPlugin;
import org.openspcoop2.monitor.engine.dynamic.DynamicFactory;
import org.openspcoop2.monitor.engine.dynamic.IDynamicLoader;
import org.openspcoop2.monitor.sdk.alarm.IAlarm;
import org.openspcoop2.monitor.sdk.constants.AlarmStateValues;
import org.openspcoop2.monitor.sdk.exceptions.AlarmException;
import org.openspcoop2.monitor.sdk.plugins.IAlarmProcessing;
import org.openspcoop2.utils.Utilities;
import org.openspcoop2.utils.date.DateManager;
import org.openspcoop2.utils.id.IDUtilities;
import org.slf4j.Logger;

/**
 * AlarmLibrary
 *
 * @author Poli Andrea (apoli@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */
public class AlarmThread implements Runnable {

    private int periodMillis;
    private String tipo;
    private String classname;
    private IAlarm alarm;
    private Logger _log;
    @SuppressWarnings("unused")
    private AlarmEngineConfig alarmEngineConfig;
    private String threadName;
    private AlarmThreadStatus threadStatus = null;
    private boolean terminated = false;
    private boolean forceNewCheck = false;
    
    private AlarmLogger alarmLogger;
    
    public boolean isTerminated() {
        return this.terminated;
    }

    public void setStop(boolean stop) {
        this.threadStatus.setStop(stop);
    }
    
    public void forceNewCheck() {
        this.forceNewCheck = true;
    }

    public AlarmThread(Logger log,String tipo, String classname, IAlarm alarm, AlarmEngineConfig alarmEngineConfig)
            throws AlarmException {
        if (tipo == null)
            throw new AlarmException(
                    "parametro tipo NULL passato al thread");
        if (classname == null)
            throw new AlarmException(
                    "parametro classname NULL passato al thread");
        if (alarm == null)
            throw new AlarmException(
                    "parametro alarm NULL passato al thread");
        this.tipo = tipo;
        this.classname = classname;
        this.alarm = alarm;
        this._log = log;
        this.alarmEngineConfig = alarmEngineConfig;
        this.threadName = "T_"+IDUtilities.getUniqueSerialNumber("newAlarmThread")+"_"+DateManager.getTimeMillis();
        ((AlarmImpl)this.alarm).setThreadName(this.threadName);
        this.threadStatus = new AlarmThreadStatus();
        ((AlarmImpl)this.alarm).setAlarmThreadStatus(this.threadStatus);
        
        this.alarmLogger = (AlarmLogger) alarm.getLogger();
    }

    public void updateState(AlarmStateValues alarmStatus){
        this.alarm.getStatus().setStatus(alarmStatus);
        switch (alarmStatus) {
        case OK:
            this.alarm.getConfigAllarme().setStato(AllarmiConverterUtils.toIntegerValue(StatoAllarme.OK));
            break;
        case WARNING:
            this.alarm.getConfigAllarme().setStato(AllarmiConverterUtils.toIntegerValue(StatoAllarme.WARNING));
            break;
        case ERROR:
            this.alarm.getConfigAllarme().setStato(AllarmiConverterUtils.toIntegerValue(StatoAllarme.ERROR));
            break;
        }
    }
    
    public void updateAcknowledged(boolean acknoledgement){
        if(acknoledgement){
            this.alarm.getConfigAllarme().setAcknowledged(1);
        }else{
            this.alarm.getConfigAllarme().setAcknowledged(0);
        }
    }
    
    public void setPeriodByDays(int days) {
        this.periodMillis = days * 24 * 60 * 60 * 1000;
    }

    public void setPeriodByHours(int hours) {
        this.periodMillis = hours * 60 * 60 * 1000;
    }

    public void setPeriodByMinutes(int minutes) {
        this.periodMillis = minutes * 60 * 1000;
    }

    public void setPeriodBySeconds(int seconds) {
        this.periodMillis = seconds * 1000;
    }

    @Override
    public void run() {
        
        try{
        
            this.alarmLogger.debug("Thread avviato ...");
            
            while (this.threadStatus.isStop() == false) {
                try {
                    
                    this.alarmLogger.info("Verifica stato in corso ...");
                    
//                  org.openspcoop2.monitor.sdk.alarm.AlarmStatus oldStatus = null;
//                  if(this.alarm.getStatus()!=null){
//                      oldStatus = (org.openspcoop2.monitor.sdk.alarm.AlarmStatus) this.alarm.getStatus().clone();
//                  }
                    
                    TipoPlugin tipoPlugin = TipoPlugin.ALLARME;
                    IDynamicLoader cAllarme = DynamicFactory.getInstance().newDynamicLoader(tipoPlugin, this.tipo, this.classname, this._log);
                    IAlarmProcessing alarmProc = (IAlarmProcessing) cAllarme.newInstance();
                    this.alarmLogger.debug("Invocazione plugin '"+this.tipo+"' ...");
                    alarmProc.check(this.alarm);
                    this.alarmLogger.debug("Invocazione plugin '"+this.tipo+"' terminato");
                    
                    // la notifica di cambio stato viene attuata quando si effettua il changeStatus sull'allarme
//                  this.alarmLogger.debug("Invocazione plugin '"+this.tipo+"' terminata; analisi nuovo stato in corso ...");
//                  
//                  AlarmManager.notifyChangeStatus(this.alarmEngineConfig, this.alarm.getConfigAllarme(),
//                          this.alarm, this.classname, this.threadName,
//                          this.alarmLogger,
//                          oldStatus, this.alarm.getStatus(),
//                          true);
//                  
//                  this.alarmLogger.info("Analisi nuovo stato terminata correttamente");
                } catch (Exception e) {
                    this.alarmLogger.error("Errore inatteso emerso durante la verifica dello stato: "
                                    + e.getMessage(), e);
                }
                int sleep = 0;
                int timeSleep = 500;
                this.alarmLogger.debug("Sleep "+this.periodMillis+"ms ...");
                while(sleep<this.periodMillis && this.threadStatus.isStop()==false){
                    Utilities.sleep(timeSleep);
                    sleep = sleep+timeSleep;
                    if(this.forceNewCheck) {
                        break;
                    }
                }
                if(this.forceNewCheck) {
                    this.alarmLogger.debug("Sleep terminata prematuramente; è stato richiesto un nuovo controllo senza attendere il normale intervallo temporale");
                    this.forceNewCheck = false;
                }
                else {
                    this.alarmLogger.debug("Sleep "+this.periodMillis+"ms terminato");
                }
            }
            
            this.alarmLogger.debug("Thread terminato");
        }finally{
            this.terminated = true;
        }
    }
        
    public String getStatoAllarme() {
        return this.alarmLogger.getStatoAllarme();
    }
}