PluginService.java

/*
 * Copyright (c) 2002-2022, City of Paris
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  1. Redistributions of source code must retain the above copyright notice
 *     and the following disclaimer.
 *
 *  2. Redistributions in binary form must reproduce the above copyright notice
 *     and the following disclaimer in the documentation and/or other materials
 *     provided with the distribution.
 *
 *  3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * License 1.0
 */
package fr.paris.lutece.portal.service.plugin;

import java.io.File;
import java.io.FileInputStream;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.TreeSet;

import fr.paris.lutece.portal.service.database.AppConnectionService;
import fr.paris.lutece.portal.service.datastore.DatastoreService;
import fr.paris.lutece.portal.service.init.LuteceInitException;
import fr.paris.lutece.portal.service.util.AppLogService;
import fr.paris.lutece.portal.service.util.AppPathService;
import fr.paris.lutece.util.filesystem.FileListFilter;

/**
 * This class provides services and utilities for plugins management
 */
public final class PluginService
{
    // Constantes
    private static final String PATH_CONF = "path.conf";
    private static final String CORE_XML = "core.xml";
    private static final String CORE = "core";
    private static Plugin _pluginCore;
    private static final String PATH_PLUGIN = "path.plugins";
    private static final String FILE_PLUGINS_STATUS = "plugins.dat";
    private static final String EXTENSION_FILE = "xml";
    private static final String PROPERTY_IS_INSTALLED = ".installed";
    private static final String PROPERTY_DB_POOL_NAME = ".pool";
    private static final String KEY_PLUGINS_STATUS = "core.plugins.status.";

    // Variables
    private static Map<String, Plugin> _mapPlugins = new HashMap<>( );
    private static List<PluginEventListener> _listPluginEventListeners = new ArrayList<>( );

    /**
     * Creates a new PluginService object.
     */
    private PluginService( )
    {
    }

    /**
     * Initialize the service
     * 
     * @throws LuteceInitException
     *             If an error occured
     */
    public static void init( ) throws LuteceInitException
    {
        loadPluginsStatus( );
        _mapPlugins.clear( );
        loadCoreComponents( );
        loadPlugins( );
    }

    /**
     * Returns the plugins file list
     *
     * @return the plugins file list as a File[]
     */
    public static Collection<Plugin> getPluginList( )
    {
        return new TreeSet<>( _mapPlugins.values( ) );
    }

    /**
     * Returns a Plugin object from its name
     *
     * @param strPluginName
     *            The name of the plugin
     * @return The Plugin object corresponding to the name
     */
    public static Plugin getPlugin( String strPluginName )
    {
        return _mapPlugins.get( strPluginName );
    }

    /**
     * Load components of the core.
     * 
     * @throws LuteceInitException
     *             If an error occured
     */
    private static void loadCoreComponents( ) throws LuteceInitException
    {
        File file = new File( AppPathService.getPath( PATH_CONF, CORE_XML ) );

        if ( file.exists( ) )
        {
            loadPluginFromFile( file, false );
        }
    }

    /**
     * Load all plugins installed on the system.
     * 
     * @throws LuteceInitException
     *             If an error occured
     */
    private static void loadPlugins( ) throws LuteceInitException
    {
        File dirPlugin = new File( AppPathService.getPath( PATH_PLUGIN ) );

        if ( dirPlugin.exists( ) )
        {
            FilenameFilter select = new FileListFilter( "", EXTENSION_FILE );
            File [ ] listFile = dirPlugin.listFiles( select );

            for ( File file : listFile )
            {
                loadPluginFromFile( file, true );
            }
        }
    }

    /**
     * Load a plugin from a file definition
     * 
     * @param file
     *            The plugin file
     * @param bRegisterAsPlugin
     *            Register it as a plugin : true for plugins, false for core components file
     * @throws LuteceInitException
     *             If an error occured
     */
    private static void loadPluginFromFile( File file, boolean bRegisterAsPlugin ) throws LuteceInitException
    {
        PluginFile pluginFile = new PluginFile( );
        pluginFile.load( file.getAbsolutePath( ) );

        String strPluginClass = pluginFile.getPluginClass( );

        if ( strPluginClass != null )
        {
            try
            {
                Plugin plugin = (Plugin) Class.forName( strPluginClass ).newInstance( );
                plugin.load( pluginFile );

                if ( bRegisterAsPlugin )
                {
                    plugin.setStatus( getPluginStatus( plugin ) );
                    registerPlugin( plugin );
                }
                else
                {
                    plugin.setStatus( true );
                    registerCore( plugin );
                }

                // If the plugin requires a database connection pool then
                // get the pool name and initialize its ConnectionService
                if ( plugin.isDbPoolRequired( ) )
                {
                    String strPoolName = getPluginPoolName( plugin );
                    plugin.setPoolName( strPoolName );
                    plugin.initConnectionService( strPoolName );
                }

                plugin.init( );

                // plugin installed event
                PluginEvent event = new PluginEvent( plugin, PluginEvent.PLUGIN_INSTALLED );
                notifyListeners( event );
            }
            catch( Exception e )
            {
                throw new LuteceInitException( "Error instantiating plugin defined in file : " + file.getAbsolutePath( ), e );
            }
        }
        else
        {
            AppLogService.error( "No plugin class defined in file : {}", file.getAbsolutePath( ) );
        }
    }

    /**
     * Register the plugin as a plugin loaded in the system
     *
     * @param plugin
     *            The plugin object
     */
    private static void registerPlugin( Plugin plugin )
    {
        _mapPlugins.put( plugin.getName( ), plugin );

        String strStatusWarning = ( plugin.isInstalled( ) ) ? "" : " *** Warning : current status is 'disabled' ***";
        AppLogService.info( "New Plugin registered : {} {}", plugin.getName( ), strStatusWarning );
    }

    /**
     * Gets the core plugin
     * 
     * @param plugin
     *            the plugin
     */
    private static synchronized void registerCore( Plugin plugin )
    {
        _pluginCore = plugin;
    }

    /**
     * Gets the core.
     *
     * @return the core
     */
    public static Plugin getCore( )
    {
        return _pluginCore;
    }

    /**
     * Update plugins data.
     *
     * @param plugin
     *            The plugin object
     */
    public static void updatePluginData( Plugin plugin )
    {
        String strKey = getInstalledKey( plugin.getName( ) );
        String strValue = plugin.isInstalled( ) ? DatastoreService.VALUE_TRUE : DatastoreService.VALUE_FALSE;
        DatastoreService.setInstanceDataValue( strKey, strValue );

        if ( plugin.isDbPoolRequired( ) )
        {
            DatastoreService.setInstanceDataValue( getPoolNameKey( plugin.getName( ) ), plugin.getDbPoolName( ) );
        }
    }

    /**
     * Build the datastore key for a given plugin
     * 
     * @param strPluginName
     *            The plugin name
     * @return The key
     */
    private static String getInstalledKey( String strPluginName )
    {
        return KEY_PLUGINS_STATUS + strPluginName + PROPERTY_IS_INSTALLED;
    }

    /**
     * Build the datastore key for a given plugin
     * 
     * @param strPluginName
     *            The plugin name
     * @return The key
     */
    private static String getPoolNameKey( String strPluginName )
    {
        return KEY_PLUGINS_STATUS + strPluginName + PROPERTY_DB_POOL_NAME;
    }

    /**
     * Load plugins status
     */
    private static void loadPluginsStatus( )
    {
        // Load default values from the plugins.dat file
        String strPluginStatusFile = AppPathService.getPath( PATH_PLUGIN, FILE_PLUGINS_STATUS );
        File file = new File( strPluginStatusFile );
        Properties props = new Properties( );

        try ( FileInputStream fis = new FileInputStream( file ) )
        {
            props.load( fis );
        }
        catch( Exception e )
        {
            AppLogService.error( "Error loading plugin defined in file : {}", file.getAbsolutePath( ), e );
        }

        // If the keys aren't found in the datastore then create a key in it
        for ( String strKey : props.stringPropertyNames( ) )
        {
            // Initialize plugins status into Datastore
            int nPos = strKey.indexOf( PROPERTY_IS_INSTALLED );

            if ( nPos > 0 )
            {
                String strPluginName = strKey.substring( 0, nPos );
                String strDSKey = getInstalledKey( strPluginName );

                if ( !DatastoreService.existsInstanceKey( strDSKey ) )
                {
                    String strValue = String.valueOf( props.getProperty( strKey ).equals( "1" ) );
                    DatastoreService.setInstanceDataValue( strDSKey, strValue );
                }
            }

            // Initialize plugins connection pool into Datastore
            nPos = strKey.indexOf( PROPERTY_DB_POOL_NAME );

            if ( nPos > 0 )
            {
                String strPluginName = strKey.substring( 0, nPos );
                String strDSKey = getPoolNameKey( strPluginName );

                if ( !DatastoreService.existsInstanceKey( strDSKey ) )
                {
                    String strValue = props.getProperty( strKey );
                    DatastoreService.setInstanceDataValue( strDSKey, strValue );
                }
            }
        }
    }

    /**
     * Gets the plugin status
     *
     * @param plugin
     *            The plugin object
     * @return true if installed, otherwise false
     */
    private static boolean getPluginStatus( Plugin plugin )
    {
        String strValue = DatastoreService.getInstanceDataValue( getInstalledKey( plugin.getName( ) ), DatastoreService.VALUE_FALSE );

        return strValue.equals( DatastoreService.VALUE_TRUE );
    }

    /**
     * Gets the pool that should be used by the plugin
     *
     * @param plugin
     *            The plugin Object
     * @return the pool name
     */
    private static String getPluginPoolName( Plugin plugin )
    {
        String strPoolname = DatastoreService.getInstanceDataValue( getPoolNameKey( plugin.getName( ) ), AppConnectionService.NO_POOL_DEFINED );

        if ( strPoolname.equals( AppConnectionService.NO_POOL_DEFINED ) && plugin.isDbPoolRequired( ) && !plugin.getName( ).equals( CORE ) )
        {
            AppLogService.info( " *** WARNING *** - The plugin '{}' has no pool defined in db.properties or datastore. Using the default pool '{}' instead.",
                    plugin, AppConnectionService.DEFAULT_POOL_NAME );
            strPoolname = AppConnectionService.DEFAULT_POOL_NAME;
        }

        return strPoolname;
    }

    /**
     * Gets the plugin status enable / disable
     * 
     * @param strPluginName
     *            The plugin name
     * @return True if the plugin is enable, otherwise false
     */
    public static boolean isPluginEnable( String strPluginName )
    {
        if ( strPluginName.equals( CORE ) )
        {
            return true;
        }

        Plugin plugin = getPlugin( strPluginName );

        return ( ( plugin != null ) && ( plugin.isInstalled( ) ) );
    }

    /**
     * Register a Plugin Event Listener
     * 
     * @param listener
     *            The listener
     */
    public static void registerPluginEventListener( PluginEventListener listener )
    {
        _listPluginEventListeners.add( listener );
    }

    /**
     * Notify an event to all Plugin Event Listeners
     * 
     * @param event
     *            The event
     */
    public static void notifyListeners( PluginEvent event )
    {
        for ( PluginEventListener listener : _listPluginEventListeners )
        {
            listener.processPluginEvent( event );
        }
    }
}