org.cloudifysource.usm.USMLifecycleBean.java Source code

Java tutorial

Introduction

Here is the source code for org.cloudifysource.usm.USMLifecycleBean.java

Source

/*******************************************************************************
 * Copyright (c) 2011 GigaSpaces Technologies Ltd. All rights reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *******************************************************************************/
package org.cloudifysource.usm;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.logging.Level;

import javax.annotation.PostConstruct;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DurationFormatUtils;
import org.cloudifysource.dsl.LifecycleEvents;
import org.cloudifysource.dsl.Service;
import org.cloudifysource.dsl.internal.CloudifyConstants;
import org.cloudifysource.usm.details.Details;
import org.cloudifysource.usm.dsl.DSLCommandsLifecycleListener;
import org.cloudifysource.usm.dsl.ServiceConfiguration;
import org.cloudifysource.usm.events.EventResult;
import org.cloudifysource.usm.events.InitListener;
import org.cloudifysource.usm.events.InstallListener;
import org.cloudifysource.usm.events.PostInstallListener;
import org.cloudifysource.usm.events.PostStartListener;
import org.cloudifysource.usm.events.PostStopListener;
import org.cloudifysource.usm.events.PreInstallListener;
import org.cloudifysource.usm.events.PreServiceStartListener;
import org.cloudifysource.usm.events.PreServiceStopListener;
import org.cloudifysource.usm.events.PreStartListener;
import org.cloudifysource.usm.events.PreStopListener;
import org.cloudifysource.usm.events.ShutdownListener;
import org.cloudifysource.usm.events.StartReason;
import org.cloudifysource.usm.events.StopListener;
import org.cloudifysource.usm.events.StopReason;
import org.cloudifysource.usm.events.USMEvent;
import org.cloudifysource.usm.launcher.ProcessLauncher;
import org.cloudifysource.usm.liveness.LivenessDetector;
import org.cloudifysource.usm.locator.ProcessLocator;
import org.cloudifysource.usm.monitors.Monitor;
import org.cloudifysource.usm.shutdown.ProcessKiller;
import org.cloudifysource.usm.stopDetection.StopDetector;
import org.openspaces.core.cluster.ClusterInfo;
import org.openspaces.core.cluster.ClusterInfoAware;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**************
 * Bean that wraps the various USM lifecycle listeners, events and invocations.
 *
 * @author barakme
 * @since 1.0
 *
 */
@Component
public class USMLifecycleBean implements ClusterInfoAware {

    private static final int DEFAULT_PIDS_SIZE_LIMIT = 10;
    @Autowired(required = true)
    private ServiceConfiguration configuration;
    @Autowired(required = true)
    private USMComponent[] components = new USMComponent[0];
    // /////////////////////////////
    // Lifecycle Implementations //
    // /////////////////////////////
    @Autowired(required = true)
    private ProcessLauncher launcher = null;
    @Autowired(required = true)
    private ProcessKiller processKiller = null;
    @Autowired(required = false)
    private LivenessDetector[] livenessDetectors = new LivenessDetector[0];
    @Autowired(required = false)
    private final StopDetector[] stopDetectors = new StopDetector[0];
    @Autowired(required = false)
    private final ProcessLocator[] processLocators = new ProcessLocator[0];

    private static final java.util.logging.Logger logger = java.util.logging.Logger
            .getLogger(USMLifecycleBean.class.getName());
    // Initialized in getClusterInfo
    private java.util.logging.Logger eventLogger;

    private String puName;
    private Integer instanceId;

    // ////////////////////////
    // Lifecycle Events //////
    // ////////////////////////
    @Autowired(required = false)
    private InitListener[] initListeners = new InitListener[0];
    @Autowired(required = false)
    private PreInstallListener[] preInstallListeners = new PreInstallListener[0];
    @Autowired(required = false)
    private final InstallListener[] installListeners = new InstallListener[0];
    @Autowired(required = false)
    private PostInstallListener[] postInstallListeners = new PostInstallListener[0];
    @Autowired(required = false)
    private PreStartListener[] preStartListeners = new PreStartListener[0];
    @Autowired(required = false)
    private PostStartListener[] postStartListeners = new PostStartListener[0];
    @Autowired(required = false)
    private PreStopListener[] preStopListeners = new PreStopListener[0];
    @Autowired(required = false)
    private final StopListener[] stopListeners = new StopListener[0];
    @Autowired(required = false)
    private PostStopListener[] postStopListeners = new PostStopListener[0];
    @Autowired(required = false)
    private ShutdownListener[] shutdownListeners = new ShutdownListener[0];
    @Autowired(required = false)
    private final PreServiceStartListener[] preServiceStartListeners = new PreServiceStartListener[0];
    @Autowired(required = false)
    private final PreServiceStopListener[] preServiceStopListeners = new PreServiceStopListener[0];

    // ////////////
    // Monitors //
    // ////////////
    @Autowired(required = false)
    private Monitor[] monitors = new Monitor[0];

    // ///////////////////
    // Service Details //
    // ///////////////////
    @Autowired(required = false)
    private Details[] details = new Details[0];
    private String eventPrefix;

    /**********
     * Post construct method.
     */
    @PostConstruct
    public void init() {
        if (this.eventLogger == null) {
            // This can only happen in the integrated container
            this.eventLogger = java.util.logging.Logger
                    .getLogger(USMLifecycleBean.class.getPackage().getName() + ".USMEventLogger.USM");

        }
        if (puName != null) {
            this.eventPrefix = puName + "-" + this.instanceId + " ";
        } else {
            this.eventPrefix = "USM-1 ";
        }

    }

    private boolean isLoggableEvent(final LifecycleEvents event, final USMEvent[] listeners) {

        if (eventLogger.isLoggable(Level.INFO)) {
            if (listeners != null) {
                if (listeners.length > 0) {
                    if (listeners.length == 1) {
                        // check for a DSL lifecycle listener
                        if (listeners[0] instanceof DSLCommandsLifecycleListener) {
                            final DSLCommandsLifecycleListener dslListener = (DSLCommandsLifecycleListener) listeners[0];
                            if (!dslListener.isEventExists(event)) {
                                return false;
                            }
                        }
                    }
                    return true;
                }
            }

        }

        return false;
    }

    private void logEventStart(final LifecycleEvents event, final USMEvent[] listeners) {
        if (isLoggableEvent(event, listeners)) {
            eventLogger.info(eventPrefix + event.toString() + " invoked");
        }
    }

    /********
     * logs the start event.
     */
    public void logProcessStartEvent() {
        if (eventLogger.isLoggable(Level.INFO)) {
            eventLogger.info(eventPrefix + "START invoked");
        }
    }

    /*******
     * Published a USM lifecycle log.
     * @param message the log message.
     */
    public void log(final String message) {
        if (eventLogger.isLoggable(Level.INFO)) {
            eventLogger.info(eventPrefix + message);
        }
    }

    /*******
     * Logs the start failed event.
     *
     * @param exceptionMessage
     *            start failure description.
     */
    public void logProcessStartFailureEvent(final String exceptionMessage) {
        if (eventLogger.isLoggable(Level.INFO)) {
            eventLogger.info(eventPrefix + "START failed. Reason: " + exceptionMessage);
        }
    }

    private void logEventSuccess(final LifecycleEvents event, final USMEvent[] listeners,
            final long eventStartTime) {
        if (isLoggableEvent(event, listeners)) {
            long eventExecDuration = System.currentTimeMillis() - eventStartTime;
            String durationAsString = DurationFormatUtils.formatDuration(eventExecDuration, "s.S");
            float formattedDurationAsLong = Float.parseFloat(durationAsString);
            String formattedDurationAsString = String.format("%.1f", formattedDurationAsLong);
            eventLogger.info(eventPrefix + event + CloudifyConstants.USM_EVENT_EXEC_SUCCESSFULLY + ", duration: "
                    + formattedDurationAsString + " seconds");
        }
    }

    private void logEventFailure(final LifecycleEvents event, final USMEvent[] listeners, final EventResult er) {
        if (eventLogger.isLoggable(Level.INFO)) {
            eventLogger.info(eventPrefix + event + CloudifyConstants.USM_EVENT_EXEC_FAILED + ". Reason: "
                    + er.getException().getMessage());

        }
    }

    /*********
     * Fires the pre-stop event.
     *
     * @param reason
     *            .
     * @throws USMException .
     */
    public void firePreStop(final StopReason reason) throws USMException {
        fireEvent(LifecycleEvents.PRE_STOP, this.preStopListeners, reason);

    }

    /*********
     * Fires the stop event.
     *
     * @param reason
     *            .
     * @throws USMException .
     */
    public void fireStop(final StopReason reason) throws USMException {
        fireEvent(LifecycleEvents.STOP, this.stopListeners, reason);

    }

    public String getOutputReaderLoggerName() {
        return configuration.getService().getName() + "-stdout";
    }

    public String getErrorReaderLoggerName() {
        return configuration.getService().getName() + "-stderr";
    }

    /***********
     * Fires an event.
     *
     * @param reason
     *            the start reason.
     * @throws USMException
     *             if an event listener failed.
     */
    public void firePostStart(final StartReason reason) throws USMException {
        fireEvent(LifecycleEvents.POST_START, this.postStartListeners, reason);
    }

    /***********
     * Fires an event.
     *
     * @param reason
     *            the start reason.
     * @throws USMException
     *             if an event listener failed.
     */
    public void firePreStart(final StartReason reason) throws USMException {
        fireEvent(LifecycleEvents.PRE_START, this.preStartListeners, reason);

    }

    /***********
     * Executes the install phase.
     *
     * @throws USMException
     *             in case of an error.
     */
    public void install() throws USMException {
        firePreInstall();
        fireInstall();
        firePostInstall();

    }

    private void fireInstall() throws USMException {
        fireEvent(LifecycleEvents.INSTALL, this.installListeners, null);
    }

    /***********
     * Fires an event.
     *
     * @throws USMException
     *             if an event listener failed.
     */
    public void firePostInstall() throws USMException {
        fireEvent(LifecycleEvents.POST_INSTALL, this.postInstallListeners, null);
    }

    /***********
     * Fires an event.
     *
     * @throws USMException
     *             if an event listener failed.
     */
    public void fireShutdown() throws USMException {
        fireEvent(LifecycleEvents.SHUTDOWN, this.shutdownListeners, null);
    }

    /***********
     * Fires an event.
     *
     * @throws USMException
     *             if an event listener failed.
     */
    public void firePreInstall() throws USMException {
        fireEvent(LifecycleEvents.PRE_INSTALL, this.preInstallListeners, null);
    }

    private void fireEvent(final LifecycleEvents event, final USMEvent[] listeners, final Object reason)
            throws USMException {
        if (listeners != null && listeners.length > 0) {
            logEventStart(event, listeners);
            long eventStartTime = System.currentTimeMillis();
            for (final USMEvent listener : listeners) {
                EventResult er = null;
                switch (event) {
                case PRE_SERVICE_START:
                    er = ((PreServiceStartListener) listener).onPreServiceStart();
                    break;
                case INIT:
                    er = ((InitListener) listener).onInit();
                    break;
                case PRE_INSTALL:
                    er = ((PreInstallListener) listener).onPreInstall();
                    break;
                case INSTALL:
                    er = ((InstallListener) listener).onInstall();
                    break;
                case POST_INSTALL:
                    er = ((PostInstallListener) listener).onPostInstall();
                    break;
                case PRE_START:
                    er = ((PreStartListener) listener).onPreStart((StartReason) reason);
                    break;
                case POST_START:
                    er = ((PostStartListener) listener).onPostStart((StartReason) reason);
                    break;
                case PRE_STOP:
                    er = ((PreStopListener) listener).onPreStop((StopReason) reason);
                    break;
                case STOP:
                    er = ((StopListener) listener).onStop((StopReason) reason);
                    break;
                case POST_STOP:
                    er = ((PostStopListener) listener).onPostStop((StopReason) reason);
                    break;
                case SHUTDOWN:
                    er = ((ShutdownListener) listener).onShutdown();
                    break;
                case PRE_SERVICE_STOP:
                    er = ((PreServiceStopListener) listener).onPreServiceStop();
                    break;

                default:
                    break;
                }

                if (er == null) {
                    throw new IllegalStateException("An event execution returned a null value!");
                }
                if (!er.isSuccess()) {
                    logEventFailure(event, listeners, er);
                    throw new USMException(
                            "Failed to execute event: " + event + ". Error was: " + er.getException());
                }
            }
            logEventSuccess(event, listeners, eventStartTime);
        }
    }

    /***********
     * Fires an event.
     *
     * @throws USMException
     *             if an event listener failed.
     */
    public void fireInit() throws USMException {
        fireEvent(LifecycleEvents.INIT, this.initListeners, null);
    }

    /***********
     * Fires an event.
     *
     * @param reason
     *            the stop reason.
     * @throws USMException
     *             if an event listener failed.
     */
    public void firePostStop(final StopReason reason) throws USMException {
        fireEvent(LifecycleEvents.POST_STOP, this.postStopListeners, reason);
    }

    /***********
     * Fires an event.
     *
     * @throws USMException
     *             if an event listener failed.
     */
    public void firePreServiceStart() throws USMException {
        fireEvent(LifecycleEvents.PRE_SERVICE_START, this.preServiceStartListeners, null);
    }

    /***********
     * Fires an event.
     *
     * @throws USMException
     *             if an event listener failed.
     */
    public void firePreServiceStop() throws USMException {
        fireEvent(LifecycleEvents.PRE_SERVICE_STOP, this.preServiceStopListeners, null);
    }

    // /////////////
    // Accessors //
    // /////////////
    public ProcessLauncher getLauncher() {
        return this.launcher;
    }

    public void setLauncher(final ProcessLauncher launcher) {
        this.launcher = launcher;
    }

    public ProcessKiller getProcessKiller() {
        return this.processKiller;
    }

    public void setProcessKiller(final ProcessKiller processKiller) {
        this.processKiller = processKiller;
    }

    public void setPostDeployListeners(final InitListener[] postDeployListeners) {
        this.initListeners = postDeployListeners;
    }

    public PreInstallListener[] getPreInstallListeners() {
        return this.preInstallListeners;
    }

    public InstallListener[] getInstallListeners() {
        return this.installListeners;
    }

    public void setPreInstallListeners(final PreInstallListener[] preInstallListeners) {
        this.preInstallListeners = preInstallListeners;
    }

    public PostInstallListener[] getPostInstallListeners() {
        return this.postInstallListeners;
    }

    public void setPostInstallListeners(final PostInstallListener[] postInstallListeners) {
        this.postInstallListeners = postInstallListeners;
    }

    public PreStartListener[] getPreStartListeners() {
        return this.preStartListeners;
    }

    public void setPreStartListeners(final PreStartListener[] preStartListeners) {
        this.preStartListeners = preStartListeners;
    }

    public PostStartListener[] getPostStartListeners() {
        return this.postStartListeners;
    }

    public void setPostStartListeners(final PostStartListener[] postStartListeners) {
        this.postStartListeners = postStartListeners;
    }

    public PreStopListener[] getPreStopListeners() {
        return this.preStopListeners;
    }

    public StopListener[] getStopListeners() {
        return this.stopListeners;
    }

    public void setPreStopListeners(final PreStopListener[] preStopListeners) {
        this.preStopListeners = preStopListeners;
    }

    public PostStopListener[] getPostStopListeners() {
        return this.postStopListeners;
    }

    public void setPostStopListeners(final PostStopListener[] postStopListeners) {
        this.postStopListeners = postStopListeners;
    }

    public Monitor[] getMonitors() {
        return this.monitors;
    }

    public void setMonitors(final Monitor[] monitors) {
        this.monitors = monitors;
    }

    public ServiceConfiguration getConfiguration() {
        return this.configuration;
    }

    public ShutdownListener[] getPreUndeployListeners() {
        return this.shutdownListeners;
    }

    public void setPreUndeployListeners(final ShutdownListener[] preUndeployListeners) {
        this.shutdownListeners = preUndeployListeners;
    }

    public USMComponent[] getComponents() {
        return this.components;
    }

    public void setComponents(final USMComponent[] components) {
        this.components = components;
    }

    public InitListener[] getInitListeners() {
        return this.initListeners;
    }

    public ShutdownListener[] getShutdownListeners() {
        return this.shutdownListeners;
    }

    public void setDetails(final Details[] details) {
        this.details = details;
    }

    public Details[] getDetails() {
        return details;
    }

    public LivenessDetector[] getLivenessDetectors() {
        return livenessDetectors;
    }

    public void setLivenessDetectors(final LivenessDetector[] livenessDetectors) {
        this.livenessDetectors = livenessDetectors;
    }

    public PreServiceStartListener[] getPreServiceStartListeners() {
        return this.preServiceStartListeners;
    }

    public PreServiceStopListener[] getPreServiceStopListeners() {
        return this.preServiceStopListeners;
    }

    public Map<String, String> getCustomProperties() {
        return this.configuration.getService().getCustomProperties();
    }

    public ProcessLocator[] getProcessLocators() {
        return processLocators;
    }

    private Integer getProcessExitValue(final Process processToCheck) {
        try {
            return processToCheck.exitValue();
        } catch (final Exception e) {
            return null;
        }
    }

    /**********
     * Returns the list of Process IDs calculated by this service's process locators.
     *
     * @return the list of PIDs.
     * @throws USMException
     *             if one of the locators failed to execute.
     */
    public List<Long> getServiceProcesses() throws USMException {
        final Set<Long> set = new HashSet<Long>();
        final ProcessLocator[] locators = this.processLocators;
        for (final ProcessLocator processLocator : locators) {
            if (processLocator != null) {
                final List<Long> processIDs = processLocator.getProcessIDs();
                if (processIDs.isEmpty()) {
                    logger.warning("A process locator returned no process IDs. "
                            + "If this is normal, you can ignore this warning. "
                            + "Otherwise, check that your process locator is correctly configured");

                }
                set.addAll(processIDs);
            }
        }

        final long pidsLimit = getPidsSizeLimit();
        if (set.isEmpty()) {
            logger.warning("No process IDs were found. No process level metrics will be available.");
        } else if (set.size() > pidsLimit) {
            final String msg = "Number of process IDs found for a service exceeded the limit of: " + pidsLimit;
            logger.severe(msg);
            throw new USMException(msg);
        }

        return new ArrayList<Long>(set);
    }

    private int getPidsSizeLimit() {
        final Service service = this.configuration.getService();
        final String limitString = service.getCustomProperties()
                .get(CloudifyConstants.CUSTOM_PROPERTY_PIDS_SIZE_LIMIT);
        if (StringUtils.isBlank(limitString)) {
            return DEFAULT_PIDS_SIZE_LIMIT;
        } else {
            try {
                final int limit = Integer.parseInt(limitString);
                return limit;
            } catch (final NumberFormatException e) {
                throw new IllegalArgumentException("Failed to parse the pids size limit service custom property ("
                        + CloudifyConstants.CUSTOM_PROPERTY_PIDS_SIZE_LIMIT + "). Error was: " + e.getMessage(), e);
            }
        }

    }

    /********
     * Executes all start detection implementations, until all have passed or a timeout is reached. Once a start
     * detector passes, it is not executed again.
     *
     * @param launchedProcess
     *            the process launched by the service's 'start' implementation.
     * @return true if liveness test passed, false if the timeout is reached without the tests passing.
     * @throws USMException
     *             if a start detector failed, or if the 'start' process exited with a non-zero exit code.
     * @throws TimeoutException
     *             if a start detector implementation timed out.
     */
    public boolean isProcessLivenessTestPassed(final Process launchedProcess)
            throws USMException, TimeoutException {
        if (this.livenessDetectors.length == 0) {
            logger.warning("No Start Detectors have been set for this service. "
                    + "This may cause the USM to monitor an irrelevant process.");
            return true;
        }

        final long startTime = System.currentTimeMillis();
        final long endTime = startTime + TimeUnit.SECONDS
                .toMillis(configuration.getService().getLifecycle().getStartDetectionTimeoutSecs());
        int currentTestIndex = 0;

        // indicates if the process launched by START (if it exitst) is still running
        boolean processIsRunning = (launchedProcess != null);
        while (System.currentTimeMillis() < endTime && currentTestIndex < this.livenessDetectors.length) {

            // first check if process ended
            if (processIsRunning) {
                processIsRunning = checkProcessIsRunning(launchedProcess);
            }

            int index = currentTestIndex;
            if (logger.isLoggable(Level.FINE)) {
                logger.fine("Executing iteration of liveness detection test");
                logger.fine("Executing liveness detectors from index: " + index);
                logger.fine("Liveness detectors: " + Arrays.toString(this.livenessDetectors));
                logger.fine("detectors length: " + this.livenessDetectors.length);
            }
            while (index < this.livenessDetectors.length) {
                logger.fine("getting detector at index: " + index);
                final LivenessDetector detector = this.livenessDetectors[index];

                boolean testResult = false;
                try {
                    testResult = detector.isProcessAlive();
                    logger.fine("Detection Test results are: " + testResult);
                } catch (final USMException e) {
                    // may indicate that the underlying process has terminated
                    if (e.getCause() instanceof InterruptedException) {
                        // ignore
                        logger.info("A start detector failed due to an InterruptedException");
                    } else {
                        throw e;
                    }
                }

                if (testResult) {
                    // this liveness detector has succeeded.
                    ++index;
                } else {
                    break;
                }

            }

            if (index == this.livenessDetectors.length) {
                // all tests passed
                return true;
            } else {
                currentTestIndex = index;
            }

            try {
                Thread.sleep(TimeUnit.SECONDS
                        .toMillis(configuration.getService().getLifecycle().getStartDetectionIntervalSecs()));
            } catch (final InterruptedException e) {
                throw new USMException("Interruped while waiting for start detection", e);
            }
        }
        return false;

    }

    private boolean checkProcessIsRunning(final Process launchedProcess) throws USMException {
        final Integer exitCode = getProcessExitValue(launchedProcess);
        if (exitCode == null) {
            return true;
        } else {
            // the process terminated!
            if (exitCode != 0) {
                // A non-zero exit code indicates an error
                final String msg = "The launched process exited with the error exit code: " + exitCode
                        + ". Consult the logs for more details.";
                logProcessStartFailureEvent(msg);
                throw new USMException(msg);
            } else {
                // launched process terminated with no error. The actual process may be running in the
                // background, or as an OS service.
                return false;
            }
        }
    }

    @Override
    public void setClusterInfo(final ClusterInfo clusterInfo) {
        this.puName = clusterInfo.getName();
        this.instanceId = clusterInfo.getInstanceId();
        if (puName != null) {
            this.eventLogger = java.util.logging.Logger
                    .getLogger(USMLifecycleBean.class.getPackage().getName() + ".USMEventLogger." + puName);
        } else {
            this.eventLogger = java.util.logging.Logger
                    .getLogger(USMLifecycleBean.class.getPackage().getName() + ".USMEventLogger.USM");

        }

    }

    public StopDetector[] getStopDetectors() {
        return stopDetectors;
    }

    /**********
     * Executes all of the registered stop detectors, stopping if one of them indicates that the service has stopped.
     *
     * @return true if a detector discovered that the service is stopped, false otherwise.
     */
    public boolean runStopDetection() {
        logger.fine("Running iteration of stop detection");
        for (final StopDetector detector : this.stopDetectors) {

            try {
                if (detector.isServiceStopped()) {
                    logger.info("Stop detection - service has stopped!");
                    return true;
                }
            } catch (final USMException e) {
                logger.log(Level.SEVERE, "A Stop detector failed to execute. The detector was: " + detector, e);
            }
        }

        return false;
    }

    private USMEvent[] initEvents(final Set<USMEvent> allEvents, final USMEvent[] events,
            final Comparator<USMEvent> eventsComparator) {
        if (events.length > 0) {
            allEvents.addAll(Arrays.asList(events));
            if (events.length > 1) {
                Arrays.sort(events, eventsComparator);

            }
        }
        return events;

    }

    /********
     * Sorts the event arrays and initializes them.
     *
     * @param usm
     *            .
     */
    public void initEvents(final UniversalServiceManagerBean usm) {

        final Comparator<USMEvent> comp = new Comparator<USMEvent>() {

            @Override
            public int compare(final USMEvent arg0, final USMEvent arg1) {
                return arg0.getOrder() - arg1.getOrder();
            }
        };
        final Set<USMEvent> allEvents = new HashSet<USMEvent>();

        initEvents(allEvents, getInitListeners(), comp);
        initEvents(allEvents, getPreInstallListeners(), comp);
        initEvents(allEvents, getInstallListeners(), comp);
        initEvents(allEvents, getPostInstallListeners(), comp);
        initEvents(allEvents, getPreStartListeners(), comp);
        initEvents(allEvents, getPostStartListeners(), comp);
        initEvents(allEvents, getPreStopListeners(), comp);
        initEvents(allEvents, getStopListeners(), comp);
        initEvents(allEvents, getPostStopListeners(), comp);
        initEvents(allEvents, getShutdownListeners(), comp);
        initEvents(allEvents, getPreServiceStartListeners(), comp);
        initEvents(allEvents, getPreServiceStopListeners(), comp);

        initEvents(allEvents, getLivenessDetectors(), comp);
        initEvents(allEvents, getStopDetectors(), comp);

        for (final USMEvent usmEvent : allEvents) {
            usmEvent.init(usm);
        }

    }

}