AppDaemonService.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.daemon;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.TimeUnit;

import fr.paris.lutece.portal.service.datastore.DatastoreService;
import fr.paris.lutece.portal.service.init.LuteceInitException;
import fr.paris.lutece.portal.service.spring.SpringContextService;
import fr.paris.lutece.portal.service.util.AppLogService;
import fr.paris.lutece.portal.service.util.AppPropertiesService;

/**
 * this class provides methods to manage daemons services
 */
public final class AppDaemonService
{
    private static final String PROPERTY_MAX_INITIAL_START_DELAY = "daemon.maxInitialStartDelay";
    private static final String PROPERTY_DAEMON_ON_STARTUP = ".onStartUp";
    private static final String PROPERTY_DAEMON_INTERVAL = ".interval";
    private static final String KEY_DAEMON = "daemon.";
    private static final String KEY_DAEMON_PREFIX = "core." + KEY_DAEMON;
    private static final Map<String, DaemonEntry> _mapDaemonEntries = new HashMap<>( );
    private static final Random _random = new Random( );
    private static boolean _bInit;
    private static IDaemonScheduler _executor;

    /** Private constructor */
    private AppDaemonService( )
    {
    }

    /**
     * Performs initialization of the DaemonFactory. Note that this should return right away so that processing can continue (IE thread off everything)
     * 
     * @throws LuteceInitException
     *             If an error occurred
     */
    public static synchronized void init( )
    {
        // already initialized
        if ( _bInit )
        {
            return;
        }

        _executor = SpringContextService.getBean( IDaemonScheduler.BEAN_NAME );

        if ( _mapDaemonEntries.size( ) > 0 )
        {
            // Unsynchronized daemon start
            int nInitialDaemon = 0;

            for ( DaemonEntry entry : _mapDaemonEntries.values( ) )
            {
                if ( entry.onStartup( ) )
                {
                    nInitialDaemon++;
                }
            }

            int nDelay = AppPropertiesService.getPropertyInt( PROPERTY_MAX_INITIAL_START_DELAY, 30 );

            if ( nInitialDaemon > 0 )
            {
                nDelay = nDelay / nInitialDaemon;
            }

            int nInitialDelay = 0;

            // Register daemons
            for ( DaemonEntry entry : _mapDaemonEntries.values( ) )
            {
                // starts any daemon declared as startup daemons
                if ( entry.onStartup( ) )
                {
                    nInitialDelay += nDelay;

                    scheduleThread( entry, nInitialDelay );
                }
            }
        }

        _bInit = true;
    }

    /**
     * Register a daemon by its entry
     * 
     * @param entry
     *            The daemon entry
     * @throws LuteceInitException
     *             If an error occurred
     */
    public static void registerDaemon( DaemonEntry entry ) throws LuteceInitException
    {
        if ( _mapDaemonEntries.containsKey( entry.getId( ) ) )
        {
            AppLogService.error( "Ignoring attempt to register already registered daemon {}", entry.getId( ) );
            return;
        }
        String strIntervalKey = getIntervalKey( entry.getId( ) );
        String strIntervalKeyDefaultValue = null;

        // init interval value if no exists
        if ( !DatastoreService.existsInstanceKey( strIntervalKey ) )
        {
            strIntervalKeyDefaultValue = AppPropertiesService.getProperty( KEY_DAEMON + entry.getId( ) + PROPERTY_DAEMON_INTERVAL, "10" );
            DatastoreService.setInstanceDataValue( strIntervalKey, strIntervalKeyDefaultValue );
        }

        String strIntervalKeyValue = DatastoreService.getInstanceDataValue( strIntervalKey, strIntervalKeyDefaultValue );

        long lInterval = Long.parseLong( strIntervalKeyValue );

        String strOnStartupKey = getOnStartupKey( entry.getId( ) );
        String strOnStartupDefaultValue = null;

        // init onStartup value if no exists
        if ( !DatastoreService.existsInstanceKey( strOnStartupKey ) )
        {
            strOnStartupDefaultValue = AppPropertiesService.getProperty( KEY_DAEMON + entry.getId( ) + ".onstartup", "0" ).equals( "1" )
                    ? DatastoreService.VALUE_TRUE
                    : DatastoreService.VALUE_FALSE;
            DatastoreService.setInstanceDataValue( strOnStartupKey, strOnStartupDefaultValue );
        }

        String strOnStarupvalue = DatastoreService.getInstanceDataValue( strOnStartupKey, strOnStartupDefaultValue );
        boolean bOnStartup = Boolean.parseBoolean( strOnStarupvalue );

        entry.setInterval( lInterval );
        entry.setOnStartUp( bOnStartup );

        try
        {
            entry.loadDaemon( );
        }
        catch( IllegalAccessException | InstantiationException | ClassNotFoundException e )
        {
            throw new LuteceInitException( "Couldn't instantiate daemon: " + entry.getId( ), e );
        }

        // Add plugin name to Daemon class
        if ( entry.getPluginName( ) != null )
        {
            entry.getDaemon( ).setPluginName( entry.getPluginName( ) );
        }

        _mapDaemonEntries.put( entry.getId( ), entry );

        AppLogService.info( "New Daemon registered : {} ", entry.getId( ) );
    }

    /**
     * Unregister a daemon
     * 
     * @param strDaemonKey
     *            The daemon key
     */
    public static void unregisterDaemon( String strDaemonKey )
    {
        unScheduleThread( _mapDaemonEntries.get( strDaemonKey ) );
        _mapDaemonEntries.remove( strDaemonKey );
    }

    /**
     * Starts a daemon
     * 
     * @param strDaemonKey
     *            The daemon key
     */
    public static void startDaemon( String strDaemonKey )
    {
        scheduleThread( _mapDaemonEntries.get( strDaemonKey ) );
    }

    /**
     * Stops a daemon
     * 
     * @param strDaemonKey
     *            The daemon key
     */
    public static void stopDaemon( String strDaemonKey )
    {
        unScheduleThread( _mapDaemonEntries.get( strDaemonKey ) );
    }

    /**
     * Signal a daemon for execution in the immediate future.
     * <p>
     * This can fail is resources are limited, which should be exceptional.
     *
     * @param strDaemonKey
     *            the daemon key
     * @return <code>true</code> if the daemon was successfully signaled, <code>false</code> otherwise
     * @since 6.0.0
     */
    public static boolean signalDaemon( String strDaemonKey )
    {
        return signalDaemon( strDaemonKey, 0L, TimeUnit.MILLISECONDS );
    }

    /**
     * Signal a daemon for execution in the immediate future.
     * <p>
     * This can fail is resources are limited, which should be exceptional.
     *
     * @param strDaemonKey
     *            the daemon key
     * @param nDelay
     *            the delay before execution
     * @param unit
     *            the unit of <code>nDelay</code> argument
     * @return <code>true</code> if the daemon was successfully signaled, <code>false</code> otherwise
     * @since 6.0.0
     */
    public static boolean signalDaemon( String strDaemonKey, long nDelay, TimeUnit unit )
    {
        return _executor.enqueue( _mapDaemonEntries.get( strDaemonKey ), nDelay, unit );
    }

    /**
     * modify daemon interval
     * 
     * @param strDaemonKey
     *            The daemon key
     * @param strDaemonInterval
     *            the daemon interval
     */
    public static void modifyDaemonInterval( String strDaemonKey, String strDaemonInterval )
    {
        DaemonEntry entry = _mapDaemonEntries.get( strDaemonKey );

        if ( entry != null )
        {
            entry.setInterval( Long.valueOf( strDaemonInterval ) );
            DatastoreService.setInstanceDataValue( getIntervalKey( entry.getId( ) ), strDaemonInterval );
        }
    }

    /**
     * Add daemon to schedule's queue
     * 
     * @param entry
     *            The DaemonEntry
     */
    private static void scheduleThread( DaemonEntry entry )
    {
        scheduleThread( entry, _random.nextInt( AppPropertiesService.getPropertyInt( PROPERTY_MAX_INITIAL_START_DELAY, 30 ) ) );
    }

    /**
     * Add daemon to schedule's queue
     * 
     * @param entry
     *            The DaemonEntry
     * @param nInitialDelay
     *            Initial start delay
     */
    private static void scheduleThread( DaemonEntry entry, int nInitialDelay )
    {
        AppLogService.info( "Scheduling daemon {} ; first run in {} seconds", entry.getId( ), nInitialDelay );
        entry.setIsRunning( true );
        _executor.schedule( entry, nInitialDelay, TimeUnit.SECONDS );
        // update onStartup property
        DatastoreService.setInstanceDataValue( getOnStartupKey( entry.getId( ) ), DatastoreService.VALUE_TRUE );
    }

    /**
     * Remove daemon from schedule's queue
     * 
     * @param entry
     *            The DaemonEntry
     */
    private static void unScheduleThread( DaemonEntry entry )
    {
        cancelScheduledThread( entry.getId( ) );
        entry.setIsRunning( false );
        // update onStartup property
        DatastoreService.setInstanceDataValue( getOnStartupKey( entry.getId( ) ), DatastoreService.VALUE_FALSE );
        AppLogService.info( "Stopping daemon '{}'", entry.getId( ) );
    }

    /**
     * Cancel scheduled thread (don't interrupt if it is running )
     * 
     * @param strEntryId
     *            The DaemonEntry Id
     */
    protected static void cancelScheduledThread( String strEntryId )
    {
        _executor.unSchedule( _mapDaemonEntries.get( strEntryId ) );
    }

    /**
     * Get the current known DaemonEntries within the DaemonFactory
     *
     * @return the entries list of daemons declaration
     */
    public static Collection<DaemonEntry> getDaemonEntries( )
    {
        return _mapDaemonEntries.values( );
    }

    /**
     * Performs the shutdown of the DaemonFactory.
     */
    public static void shutdown( )
    {
        _executor.shutdown( );
    }

    /**
     * Gets a daemon object from its key name
     *
     * @param strDaemonKey
     *            The daemon key
     * @return The daemon
     */
    public static Daemon getDaemon( String strDaemonKey )
    {
        DaemonEntry entry = _mapDaemonEntries.get( strDaemonKey );

        return entry.getDaemon( );
    }

    /**
     * return the OnStartup key link to the daemon
     * 
     * @param strDaemonKey
     *            The daemon key
     * @return The key
     */
    private static String getOnStartupKey( String strDaemonKey )
    {
        return KEY_DAEMON_PREFIX + strDaemonKey + PROPERTY_DAEMON_ON_STARTUP;
    }

    /**
     * return the Interval key link to the daemon
     * 
     * @param strDaemonKey
     *            The daemon key
     * @return The key
     */
    private static String getIntervalKey( String strDaemonKey )
    {
        return KEY_DAEMON_PREFIX + strDaemonKey + PROPERTY_DAEMON_INTERVAL;
    }
}