PluginManager.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.dynamic;

  23. import java.util.ArrayList;
  24. import java.util.Collections;
  25. import java.util.Date;
  26. import java.util.HashMap;
  27. import java.util.List;

  29. import org.apache.commons.lang.StringUtils;
  30. import org.openspcoop2.core.commons.CoreException;
  31. import org.openspcoop2.core.config.RegistroPlugin;
  32. import org.openspcoop2.core.config.RegistroPlugins;
  33. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  34. import org.openspcoop2.generic_project.exception.NotFoundException;
  35. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  36. import org.openspcoop2.utils.SemaphoreLock;
  37. import org.openspcoop2.utils.UtilsException;
  38. import org.openspcoop2.utils.date.DateManager;
  39. import org.slf4j.Logger;

  41. /**
  42.  * PluginManager
  43.  *
  44.  * @author Poli Andrea (apoli@link.it)
  45.  * @author $Author$
  46.  * @version $Rev$, $Date$
  47.  */
  48. public class PluginManager {

  50.     private IRegistroPluginsReader registroPluginsReader;
  51.     
  52.     private Date expireDate;
  53.     private int expireSeconds;
  54.     private final org.openspcoop2.utils.Semaphore lockExpire = new org.openspcoop2.utils.Semaphore("PluginManager-expire");
  55.     
  56.     private PluginsImage pluginsImage = new PluginsImage();
  57.     private PluginsImage pluginsImageSwitchOld = null;
  58.     private final org.openspcoop2.utils.Semaphore lockImage = new org.openspcoop2.utils.Semaphore("PluginManager-image");

  60.     protected PluginManager(IRegistroPluginsReader registroPluginsReader, int expireSeconds) {
  61.         this.registroPluginsReader = registroPluginsReader;
  62.         this.expireSeconds = expireSeconds;
  63.     }

  65.     private void checkUpdate(Logger log) {
  66.         try {
  67.             Date nowDate = DateManager.getDate();
  68.             if(this.expireDate==null || nowDate.after(this.expireDate)) {
  69.                 this.update(log, nowDate);
  70.             }
  71.         }catch(Exception t) {
  72.             log.error("Update plugin image failed: "+t.getMessage(),t);
  73.         }
  74.     }
  75.     public void updateFromConsoleConfig(Logger log) {
  76.         try {
  77.             if(this.expireDate!=null) {
  78.                 Date expired = new Date(this.expireDate.getTime()+1);
  79.                 this.update(log, expired);
  80.             }
  81.         }catch(Exception t) {
  82.             log.error("Update plugin image failed: "+t.getMessage(),t);
  83.         }
  84.     }
  85.     private void update(Logger log, Date nowDate) throws UtilsException, CoreException {
  86.         
  87.         boolean update = false;
  88.         
  89.         SemaphoreLock lock = this.lockExpire.acquire("updateExpireDate");
  90.         try {
  91.             if(this.expireDate==null || nowDate.after(this.expireDate)) {
  92.                 this.expireDate = new Date(nowDate.getTime()+(this.expireSeconds*1000));
  93.                 update = true;
  94.                 // l'aggiornamento effettivo lo faccio fuori dal synchronized per non bloccare le chiamate a _findClass, intanto che l'immagine viene aggiornata
  95.                 // gli altri thread che entrano in questo metodo trovano la lor nowDate inferiore ad expireDate
  96.             }
  97.         }finally {
  98.             this.lockExpire.release(lock, "updateExpireDate");
  99.         }
  100.         
  101.         if(update) {
  102.             RegistroPlugins registro = null;
  103.             try {
  104.                 registro = this.registroPluginsReader.getRegistroPlugins();
  105.             }catch (NotFoundException notFound) {
  106.                 log.debug(notFound.getMessage(),notFound);
  107.             }
  108.             this.update(log, registro);
  109.         }
  110.     }
  111.     
  112.     private void update(Logger log, RegistroPlugins pluginsParam) throws UtilsException {
  113.         
  114.         SemaphoreLock lock = this.lockImage.acquire("update");
  115.         try {
  116.             
  117.             RegistroPlugins plugins = null;
  118.             if(pluginsParam!=null) {
  119.                 plugins = pluginsParam;
  120.             }
  121.             else {
  122.                 plugins = new RegistroPlugins();
  123.             }
  124.     
  125.             // verifico prima quelli da eliminare
  126.             List<String> pluginDaEliminare = new ArrayList<>();
  127.             if(this.pluginsImage!=null && !this.pluginsImage.plugins.isEmpty()) {
  128.                 for (String pluginName : this.pluginsImage.plugins.keySet()) {
  129.                     boolean found = false;
  130.                     if(plugins.sizePluginList()>0) {
  131.                         for (RegistroPlugin pluginNew : plugins.getPluginList()) {
  132.                             if(pluginNew.getNome().equals(pluginName)) {
  133.                                 found = true;
  134.                                 break;
  135.                             }
  136.                         }
  137.                     }
  138.                     if(!found) {
  139.                         pluginDaEliminare.add(pluginName);
  140.                     }
  141.                 }
  142.             }
  143.             
  144.             // Nuova immagine
  145.             PluginsImage newImage = null;
  146.             if(plugins.sizePluginList()>0) {
  147.                 newImage = new PluginsImage();
  148.                 HashMap<String, String> mapPosizioniToNomi = new HashMap<>();
  149.                 for (RegistroPlugin pluginNew : plugins.getPluginList()) {
  150.                     
  151.                     if(!StatoFunzionalita.ABILITATO.equals(pluginNew.getStato())) {
  152.                         continue;
  153.                     }
  154.                     if(pluginNew.sizeArchivioList()<=0) {
  155.                         continue; // vuoto
  156.                     }
  157.                     
  158.                     String posPad = StringUtils.leftPad(pluginNew.getPosizione()+"", 10);
  159.                     mapPosizioniToNomi.put(posPad, pluginNew.getNome());
  160.                     
  161.                     // check se esiste
  162.                     if(this.pluginsImage!=null && this.pluginsImage.plugins.containsKey(pluginNew.getNome())) {
  163.                         
  164.                         // check se e' stato aggiornato
  165.                         Plugin active = this.pluginsImage.plugins.get(pluginNew.getNome());
  166.                         if(pluginNew.getData().after(active.getDate())) {
  167.                             
  168.                             // Da aggiornare
  169.                             
  170.                             pluginDaEliminare.add(pluginNew.getNome()); // elimino nella vecchia immagine
  171.                             
  172.                             Plugin pluginNewInstance = null;
  173.                             try {
  174.                                 pluginNewInstance = new Plugin(pluginNew);
  175.                             }catch(Exception e) {
  176.                                 log.error("Errore durante l'istanziazione del plugin '"+pluginNew.getNome()+"': "+e.getMessage(),e);
  177.                             }
  178.                             if(pluginNewInstance!=null) {
  179.                                 newImage.plugins.put(pluginNew.getNome(), pluginNewInstance);
  180.                             }
  181.                         
  182.                         }
  183.                         else {
  184.                             
  185.                             // non modificato
  186.                             newImage.plugins.put(pluginNew.getNome(), active);
  187.                             
  188.                         }
  189.                         
  190.                     }
  191.                     else {
  192.                         Plugin pluginNewInstance = null;
  193.                         try {
  194.                             pluginNewInstance = new Plugin(pluginNew);
  195.                         }catch(Exception e) {
  196.                             log.error("Errore durante l'istanziazione del plugin '"+pluginNew.getNome()+"': "+e.getMessage(),e);
  197.                         }
  198.                         if(pluginNewInstance!=null) {
  199.                             newImage.plugins.put(pluginNew.getNome(), pluginNewInstance);
  200.                         }
  201.                     }
  202.                     
  203.                 }
  204.                 
  205.     
  206.                 // ordino per posizione
  207.                 if(!mapPosizioniToNomi.isEmpty()) {
  208.                     List<String> posizioni = new ArrayList<>();
  209.                     posizioni.addAll(mapPosizioniToNomi.keySet());
  210.                     Collections.sort(posizioni);
  211.                     for (String pos : posizioni) {
  212.                         newImage.pluginsActiveOrdered.add(mapPosizioniToNomi.get(pos));
  213.                     }
  214.                 }
  215.             }
  216.             
  217.             // effettuo switch
  218.             this.pluginsImageSwitchOld = this.pluginsImage;
  219.             this.pluginsImage = newImage;
  220.             
  221.             // Effettuo la chiusura di quelli da eliminare
  222.             if(!pluginDaEliminare.isEmpty()) {
  223.                 for (String pluginName : pluginDaEliminare) {
  224.                     try {
  225.                         this.pluginsImageSwitchOld.plugins.get(pluginName).close();
  226.                     }catch(Exception t) {
  227.                         // ignore
  228.                     }
  229.                 }
  230.             }
  231.             this.pluginsImageSwitchOld = null;
  232.                     
  233.         }finally {
  234.             this.lockImage.release(lock, "update");
  235.         }
  236.         
  237.     }
  238.     
  239.     public void close() {
  240.         
  241.         // Chiusura di tutti
  242.         SemaphoreLock lock = this.lockImage.acquireThrowRuntime("close");
  243.         try {
  244.             
  245.             if(this.pluginsImage!=null && this.pluginsImage.plugins.size()>0) {
  246.                 for (Plugin plugin : this.pluginsImage.plugins.values()) {
  247.                     try {
  248.                         plugin.close();
  249.                     }catch(Exception t) {
  250.                         // close
  251.                     }
  252.                 }
  253.             }
  254.             
  255.             if(this.pluginsImageSwitchOld!=null &&
  256.                 this.pluginsImageSwitchOld.plugins.size()>0) {
  257.                 for (Plugin plugin : this.pluginsImageSwitchOld.plugins.values()) {
  258.                     try {
  259.                         plugin.close();
  260.                     }catch(Exception t) {
  261.                         // close
  262.                     }
  263.                 }
  264.             }
  265.             
  266.         }finally {
  267.             this.lockImage.release(lock, "close");
  268.         }
  269.     }
  270.     

  272.     public Class<?> findClass(Logger log, TipoPlugin tipoClasseDaRicercare, String className) throws ClassNotFoundException {
  273.         return this.findClassEngine(log, tipoClasseDaRicercare, null, className, true);
  274.     }
  275.     public Class<?> findClass(Logger log, TipoPlugin tipoClasseDaRicercare, String className, boolean searchDefaultClassLoader) throws ClassNotFoundException {
  276.         return this.findClassEngine(log, tipoClasseDaRicercare, null, className, searchDefaultClassLoader);
  277.     }
  278.     
  279.     public Class<?> findClass(Logger log, String tipoClasseDaRicercare, String className) throws ClassNotFoundException {
  280.         return this.findClassEngine(log, null, tipoClasseDaRicercare, className, true);
  281.     }
  282.     public Class<?> findClass(Logger log, String tipoClasseDaRicercare, String className, boolean searchDefaultClassLoader) throws ClassNotFoundException {
  283.         return this.findClassEngine(log, null, tipoClasseDaRicercare, className, searchDefaultClassLoader);
  284.     }
  285.     
  286.     
  287.     
  288.     private Class<?> findClassEngine(Logger log, TipoPlugin tipoClasseDaRicercare,String tipoClasseCustomDaRicercare, String className, boolean searchDefaultClassLoader) throws ClassNotFoundException {

  290.         checkUpdate(log);
  291.         
  292.         // Se server gestire tramite una cache

  294.         // Se abilitato prima cerco sempre nel classloader attuale.
  295.         // Il classloader dinamico verrà utilizzato SOLAMENTE se il tipo non viene risolto prima tramite i meccanismi standard. 
  296.         // Questo behaviour permette di avere poi un synchronized sul semaforo del classloader dinamico solamente quando serve davvero, 
  297.         // visto che il caricamento dinamico delle classi è molto diffuso all'interno dell'architettura di GovWay.
  298.         ClassNotFoundException notFound = null;
  299.         if(searchDefaultClassLoader) {
  300.             try {
  301.                 return Class.forName(className);
  302.             }catch(ClassNotFoundException e) {
  303.                 notFound = e;
  304.             }
  305.         }
  306.         
  307.         if(this.pluginsImage!=null) { // potrebbe essere disabilitato
  308.             PluginsImage image = this.pluginsImage; // lo assegno, in modo che se avviene un update, cambia il riferimento
  309.             
  310.             if(!image.pluginsActiveOrdered.isEmpty()) {
  311.                 Class<?> c = findClassEngine(image, tipoClasseDaRicercare, tipoClasseCustomDaRicercare, className);
  312.                 if(c!=null) {
  313.                     return c;
  314.                 }
  315.             }
  316.         }
  317.         
  318.         if(notFound!=null) {
  319.             throw notFound;
  320.         }
  321.         return null;
  322.     }
  323.     private Class<?> findClassEngine(PluginsImage image, TipoPlugin tipoClasseDaRicercare, String tipoClasseCustomDaRicercare, String className){
  324.         List<String> listPluginsActiveOrdered = image.pluginsActiveOrdered;
  325.         for (String pluginName : listPluginsActiveOrdered) {
  326.             
  327.             Plugin plugin = image.plugins.get(pluginName);
  328.             if(plugin!=null) {
  329.                 Class<?> c = findClassEngineByPlugin(plugin, tipoClasseDaRicercare, tipoClasseCustomDaRicercare, className);
  330.                 if(c!=null) {
  331.                     return c;
  332.                 }
  333.             }
  334.             
  335.         }
  336.         return null;
  337.     }
  338.     private Class<?> findClassEngineByPlugin(Plugin plugin, TipoPlugin tipoClasseDaRicercare, String tipoClasseCustomDaRicercare, String className){
  339.         ClassLoader classLoader = null;
  340.         if(tipoClasseDaRicercare!=null) {
  341.             classLoader = plugin.getClassLoader(tipoClasseDaRicercare);
  342.         }else {
  343.             classLoader = plugin.getClassLoader(tipoClasseCustomDaRicercare);
  344.         }
  345.         if(classLoader!=null) {
  346.             Class<?> c = null;
  347.             try {
  348.                 c = classLoader.loadClass(className);
  349.             }catch(ClassNotFoundException cNotFound) {
  350.                 // ignore
  351.             }
  352.             if(c!=null) {
  353.                 return c;
  354.             }
  355.         }
  356.         return null;
  357.     }

  359. }

  361. class PluginsImage {
  362.     
  363.     HashMap<String, Plugin> plugins = new HashMap<>();
  364.     List<String> pluginsActiveOrdered = new ArrayList<>();
  365.     
  366. }
Created with JaCoCo 0.8.8.202204050719