PolicyGroupByActiveThreads.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.pdd.core.controllo_traffico.policy.driver;

import java.io.Serializable;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import org.openspcoop2.core.controllo_traffico.beans.ActivePolicy;
import org.openspcoop2.core.controllo_traffico.beans.DatiCollezionati;
import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupBy;
import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupByPolicy;
import org.openspcoop2.core.controllo_traffico.beans.MisurazioniTransazione;
import org.openspcoop2.core.controllo_traffico.constants.Costanti;
import org.openspcoop2.core.controllo_traffico.driver.IPolicyGroupByActiveThreadsInMemory;
import org.openspcoop2.core.controllo_traffico.driver.PolicyException;
import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
import org.openspcoop2.core.controllo_traffico.driver.PolicyNotFoundException;
import org.openspcoop2.pdd.core.controllo_traffico.policy.PolicyDateUtils;
import org.openspcoop2.protocol.utils.EsitiProperties;
import org.openspcoop2.utils.Map;
import org.openspcoop2.utils.SemaphoreLock;
import org.openspcoop2.utils.UtilsException;
import org.slf4j.Logger;

/**     
 * PolicyGroupByActiveThreads
 *
 * @author Poli Andrea (poli@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */
public class PolicyGroupByActiveThreads implements Serializable,IPolicyGroupByActiveThreadsInMemory {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> mapActiveThreads = new HashMap<IDUnivocoGroupByPolicy, DatiCollezionati>();
	
	//private final Boolean semaphore = Boolean.valueOf(false);
	private transient org.openspcoop2.utils.Semaphore _lock = null;
	private synchronized void initLock() {
		if(this._lock==null) {
			this._lock = new org.openspcoop2.utils.Semaphore("PolicyGroupByActiveThreads"); 
		}
	}
	public org.openspcoop2.utils.Semaphore getLock(){
		if(this._lock==null) {
			initLock();
		}
		return this._lock;
	}
	
	private ActivePolicy activePolicy;
	private PolicyGroupByActiveThreadsType tipoGestore;

	public PolicyGroupByActiveThreads(ActivePolicy activePolicy, PolicyGroupByActiveThreadsType tipoGestore) {
		this.activePolicy = activePolicy;
		this.tipoGestore = tipoGestore;
	}
	
	
	@Override
	public ActivePolicy getActivePolicy() {
		return this.activePolicy;
	}
	@Override
	public java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> getMapActiveThreads(){
		return this.mapActiveThreads;
	}
	
	
	public void setMapActiveThreads(java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> value) {
		this.mapActiveThreads = value;
	}
	
	@Override
	public void initMap(java.util.Map<IDUnivocoGroupByPolicy, DatiCollezionati> map) {
		/**synchronized (this.semaphore) {*/
		SemaphoreLock slock =this.getLock().acquireThrowRuntime("initMap");
		try {
			if(map!=null && map.size()>0){
				this.mapActiveThreads.putAll(map);
			}
		}finally {
			this.getLock().release(slock, "initMap");
		}
	}
	
	@Override
	public void resetCounters(){
		/**synchronized (this.semaphore) {*/
		SemaphoreLock slock =this.getLock().acquireThrowRuntime("resetCounters");
		try {
			if(this.mapActiveThreads.size()>0){
				Iterator<DatiCollezionati> datiCollezionati = this.mapActiveThreads.values().iterator();
				while (datiCollezionati.hasNext()) {
					DatiCollezionati item = datiCollezionati.next();
					item.resetCounters();
				}
			}
		}finally {
			this.getLock().release(slock, "resetCounters");
		}
	}
	
	@Override
	public void remove() throws UtilsException{
		// nop;
	}
	
	@Override
	public DatiCollezionati registerStartRequest(Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx) throws PolicyException{
				
		DatiCollezionati datiCollezionatiReaded = null;
		/**System.out.println("<"+idTransazione+">registerStartRequest ...");*/
		/**synchronized (this.semaphore) {*/
		SemaphoreLock slock =this.getLock().acquireThrowRuntime("registerStartRequest", idTransazione);
		try {
			/**System.out.println("<"+idTransazione+">registerStartRequest entrato");*/
			
			DatiCollezionati datiCollezionati = null;
			if(this.mapActiveThreads.containsKey(datiGroupBy)){
				/**System.out.println("<"+idTransazione+">registerStartRequest CHECK CONTAINS ["+datiGroupBy+"]=true");*/
				datiCollezionati = this.mapActiveThreads.get(datiGroupBy);	
			}
			else{
				/**System.out.println("<"+idTransazione+">registerStartRequest CHECK CONTAINS ["+datiGroupBy+"]=false");*/
				Date gestorePolicyConfigDate = PolicyDateUtils.readGestorePolicyConfigDateIntoContext(ctx);
				datiCollezionati = new DatiCollezionati(this.activePolicy.getInstanceConfiguration().getUpdateTime(), gestorePolicyConfigDate);
				/**System.out.println("<"+idTransazione+">registerStartRequest PUT");*/
				this.mapActiveThreads.put(datiGroupBy, datiCollezionati); // registro nuova immagine
			}
			
			// incremento il numero di thread
			/**System.out.println("<"+idTransazione+">registerStartRequest in datiCollezionati ...");*/
			datiCollezionati.registerStartRequest(log, this.activePolicy, ctx);
			/**System.out.println("<"+idTransazione+">registerStartRequest in datiCollezionati ok: "+datiCollezionati.getActiveRequestCounter());*/
									
			// mi salvo fuori dal synchronized l'attuale stato
			datiCollezionatiReaded = datiCollezionati.newInstance(); 
		
			/**System.out.println("<"+idTransazione+">registerStartRequest esco");*/
		}finally {
			this.getLock().release(slock, "registerStartRequest", idTransazione);
		}
		
		
		// Tutti i restanti controlli sono effettuati usando il valore di datiCollezionatiReaded, che e' gia' stato modificato
		// Inoltre e' stato re-inserito nella map come oggetto nuovo, quindi il valore dentro il metodo non subira' trasformazioni (essendo stato fatto il clone)
		// E' possibile procedere con l'analisi rispetto al valore che possiedono il counter dentro questo scope.
		
		return datiCollezionatiReaded;

	}
	
	@Override
	public DatiCollezionati updateDatiStartRequestApplicabile(Logger log, String idTransazione, IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx) throws PolicyException,PolicyNotFoundException{
		
		DatiCollezionati datiCollezionatiReaded = null;
		/**System.out.println("<"+idTransazione+">updateDatiStartRequestApplicabile ...");*/
		/**synchronized (this.semaphore) {*/
		SemaphoreLock slock =this.getLock().acquireThrowRuntime("updateDatiStartRequestApplicabile", idTransazione);
		try {
			/**System.out.println("<"+idTransazione+">updateDatiStartRequestApplicabile entrato");*/
			
			DatiCollezionati datiCollezionati = null;
			if(this.mapActiveThreads.containsKey(datiGroupBy)==false){
				/**System.out.println("<"+idTransazione+">updateDatiStartRequestApplicabile Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupBy.toString()+"]");*/
				throw new PolicyNotFoundException("Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupBy.toString()+"]");
			}
			else{
				datiCollezionati = this.mapActiveThreads.get(datiGroupBy);	
			}
			
			// incremento il numero dei contatori
			/**System.out.println("<"+idTransazione+">updateDatiStartRequestApplicabile updateDatiStartRequestApplicabile ...");*/
			boolean updated = datiCollezionati.updateDatiStartRequestApplicabile(log, this.activePolicy, ctx);
			/**System.out.println("<"+idTransazione+">updateDatiStartRequestApplicabile updateDatiStartRequestApplicabile ok");*/
									
			// mi salvo fuori dal synchronized l'attuale stato
			if(updated) {
				datiCollezionatiReaded = datiCollezionati.newInstance();
			}
			
			/**System.out.println("<"+idTransazione+">updateDatiStartRequestApplicabile esco");*/
		}finally {
			this.getLock().release(slock, "updateDatiStartRequestApplicabile", idTransazione);
		}
		
		// Tutti i restanti controlli sono effettuati usando il valore di datiCollezionatiReaded, che e' gia' stato modificato
		// Inoltre e' stato re-inserito nella map come oggetto nuovo, quindi il valore dentro il metodo non subira' trasformazioni (essendo stato fatto il clone)
		// E' possibile procedere con l'analisi rispetto al valore che possiedono il counter dentro questo scope.
		
		return datiCollezionatiReaded;

	}
	
	@Override
	public void registerStopRequest(Logger log, String idTransazione,IDUnivocoGroupByPolicy datiGroupBy, Map<Object> ctx, 
			MisurazioniTransazione dati, boolean isApplicabile, boolean isViolata) throws PolicyException,PolicyNotFoundException{
		/**System.out.println("<"+idTransazione+">registerStopRequest ...");*/
		/**synchronized (this.semaphore) {*/
		SemaphoreLock slock =this.getLock().acquireThrowRuntime("registerStopRequest", idTransazione);
		try {
			/**System.out.println("<"+idTransazione+">registerStopRequest entro");*/
			
			if(this.mapActiveThreads.containsKey(datiGroupBy)==false){
				/**System.out.println("<"+idTransazione+">registerStopRequest Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupBy.toString()+"]");*/
				throw new PolicyNotFoundException("Non sono presenti alcun threads registrati per la richiesta con dati identificativi ["+datiGroupBy.toString()+"]");
			}
			else{
				/**System.out.println("<"+idTransazione+">registerStopRequest get ...");*/
				DatiCollezionati datiCollezionati = this.mapActiveThreads.get(datiGroupBy);	
				/**System.out.println("<"+idTransazione+">registerStopRequest registerEndRequest ...");*/
				datiCollezionati.registerEndRequest(log, this.activePolicy, ctx, dati);
				/**System.out.println("<"+idTransazione+">registerStopRequest registerEndRequest ok");*/
				if(isApplicabile){
					/**System.out.println("<"+idTransazione+">registerStopRequest updateDatiEndRequestApplicabile ...");*/
					List<Integer> esitiCodeOk = null;
					List<Integer> esitiCodeKoSenzaFaultApplicativo = null;
					List<Integer> esitiCodeFaultApplicativo = null;
					try {
						EsitiProperties esitiProperties = EsitiProperties.getInstanceFromProtocolName(log,dati.getProtocollo());
						esitiCodeOk = esitiProperties.getEsitiCodeOk_senzaFaultApplicativo();
						esitiCodeKoSenzaFaultApplicativo = esitiProperties.getEsitiCodeKo_senzaFaultApplicativo();
						esitiCodeFaultApplicativo = esitiProperties.getEsitiCodeFaultApplicativo();
					}catch(Exception e) {
						throw new PolicyException(e.getMessage(),e);
					}
					datiCollezionati.updateDatiEndRequestApplicabile(log, this.activePolicy, ctx, dati,
							esitiCodeOk,esitiCodeKoSenzaFaultApplicativo, esitiCodeFaultApplicativo, isViolata);
					/**System.out.println("<"+idTransazione+">registerStopRequest updateDatiEndRequestApplicabile ok");*/
				}
			}
			
			/**System.out.println("<"+idTransazione+">registerStopRequest esco");*/
		}finally {
			this.getLock().release(slock, "registerStopRequest", idTransazione);
		}	
	}

	
	@Override
	public long getActiveThreads(){
		return this.getActiveThreads(null);
	}
	@Override
	public long getActiveThreads(IDUnivocoGroupByPolicy filtro){
		
		/**synchronized (this.semaphore) {*/
		SemaphoreLock slock =this.getLock().acquireThrowRuntime("getActiveThreads");
		try {
			
			long counter = 0l;
			
			if(this.mapActiveThreads!=null && !this.mapActiveThreads.isEmpty()) {
				for (IDUnivocoGroupByPolicy datiGroupBy : this.mapActiveThreads.keySet()) {
					
					if(filtro!=null){
						IDUnivocoGroupBy<IDUnivocoGroupByPolicy> idAstype = datiGroupBy;
						if(!idAstype.match(filtro)){
							continue;
						}
					}
					
					counter = counter + this.mapActiveThreads.get(datiGroupBy).getActiveRequestCounter();
				}
			}
			
			return counter;
		}finally {
			this.getLock().release(slock, "getActiveThreads");
		}
	}
	
	@Override
	public String printInfos(Logger log, String separatorGroups) throws UtilsException{
		/**synchronized (this.semaphore) {*/
		SemaphoreLock slock =this.getLock().acquireThrowRuntime("printInfos");
		try {
			StringBuilder bf = new StringBuilder();
			if(this.mapActiveThreads!=null && !this.mapActiveThreads.isEmpty()) {
				for (IDUnivocoGroupByPolicy datiGroupBy : this.mapActiveThreads.keySet()) {
					bf.append(separatorGroups);
					bf.append("\n");
					bf.append(Costanti.LABEL_MODALITA_SINCRONIZZAZIONE).append(" ").append(this.tipoGestore.toLabel());
					bf.append("\n");
					bf.append("Criterio di Collezionamento dei Dati\n");
					bf.append(datiGroupBy.toString(true));
					bf.append("\n");
					this.mapActiveThreads.get(datiGroupBy).checkDate(log, this.activePolicy); // imposta correttamente gli intervalli
					bf.append(this.mapActiveThreads.get(datiGroupBy).toString());
					bf.append("\n");
				}
			}
			if(bf.length()<=0){
				bf.append("Nessuna informazione disponibile");
				return bf.toString();
			}
			else{
				return bf.toString()+separatorGroups;
			}
		}finally {
			this.getLock().release(slock, "printInfos");
		}
	}
}