StandardService.java

/*
 * Copyright (c) 1997-2018 Oracle and/or its affiliates. All rights reserved.
 * Copyright 2004 The Apache Software Foundation
 *
 * 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.apache.catalina.core;

import static com.sun.logging.LogCleanerUtil.neutralizeForLog;
import static java.text.MessageFormat.format;
import static java.util.logging.Level.INFO;
import static java.util.logging.Level.SEVERE;
import static org.apache.catalina.LogFacade.ERROR_REGISTER_SERVICE_EXCEPTION;
import static org.apache.catalina.LogFacade.FAILED_SERVICE_INIT_EXCEPTION;
import static org.apache.catalina.LogFacade.SERVICE_STARTED;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.text.MessageFormat;
import java.util.List;
import java.util.ResourceBundle;
import java.util.logging.Logger;

import javax.management.NotificationBroadcasterSupport;
import javax.management.ObjectName;

import org.apache.catalina.Connector;
import org.apache.catalina.Container;
import org.apache.catalina.Engine;
import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.LogFacade;
import org.apache.catalina.Server;
import org.apache.catalina.ServerFactory;
import org.apache.catalina.Service;
import org.apache.catalina.util.LifecycleSupport;

/**
 * Standard implementation of the <code>Service</code> interface. The associated Container is generally an instance of
 * Engine, but this is not required.
 *
 * @author Craig R. McClanahan
 */

public class StandardService implements Lifecycle, Service {

    private static final Logger log = LogFacade.getLogger();
    private static final ResourceBundle rb = log.getResourceBundle();

    // ----------------------------------------------------- Instance Variables

    /**
     * Descriptive information about this component implementation.
     */
    private static final String info = "org.apache.catalina.core.StandardService/1.0";

    /**
     * The name of this service.
     */
    private String name;

    /**
     * The lifecycle event support for this component.
     */
    private LifecycleSupport lifecycle = new LifecycleSupport(this);

    /**
     * The <code>Server</code> that owns this Service, if any.
     */
    private Server server;

    /**
     * Has this component been started?
     */
    private boolean started;

    /**
     * The debugging detail level for this component.
     */
    protected int debug = 0;

    /**
     * The property change support for this component.
     */
    protected PropertyChangeSupport support = new PropertyChangeSupport(this);

    /**
     * The set of Connectors associated with this Service.
     */
    protected Connector connectors[] = new Connector[0];

    protected final Object connectorsMonitor = new Object();

    /**
     * The Container associated with this Service. (In the case of the org.apache.catalina.startup.Embedded subclass, this
     * holds the most recently added Engine.)
     */
    protected Container container;

    /**
     * Has this component been initialized?
     */
    protected boolean initialized;

    /**
     * The broadcaster that sends EE notifications.
     */
    private NotificationBroadcasterSupport broadcaster;

    protected String domain;
    protected ObjectName oname;

    // ----------------------------------------------------------- Constructors

    /**
     * Construct a default instance of this class.
     */

    public StandardService() {
        this.broadcaster = new NotificationBroadcasterSupport();
    }

    // ------------------------------------------------------------- Properties

    /**
     * Return the <code>Container</code> that handles requests for all <code>Connectors</code> associated with this Service.
     */
    @Override
    public Container getContainer() {
        return  container;
    }

    /**
     * Set the <code>Container</code> that handles requests for all <code>Connectors</code> associated with this Service.
     *
     * @param container The new Container
     */
    @Override
    public void setContainer(Container container) {
        Container oldContainer = this.container;
        if ((oldContainer != null) && (oldContainer instanceof Engine)) {
            ((Engine) oldContainer).setService(null);
        }

        this.container = container;
        if (this.container instanceof Engine) {
            ((Engine) this.container).setService(this);
        }

        if (started && (this.container != null) && (this.container instanceof Lifecycle)) {
            try {
                ((Lifecycle) this.container).start();
            } catch (LifecycleException e) {
                // Ignore
            }
        }

        synchronized (connectorsMonitor) {
            for (Connector connector : connectors) {
                connector.setContainer(this.container);
            }
        }

        if (started && (oldContainer != null) && (oldContainer instanceof Lifecycle)) {
            try {
                ((Lifecycle) oldContainer).stop();
            } catch (LifecycleException e) {
                // Ignore
            }
        }

        // Report this property change to interested listeners
        support.firePropertyChange("container", oldContainer, this.container);

    }

    public ObjectName getContainerName() {
        if (container instanceof ContainerBase) {
            return ((ContainerBase) container).getJmxName();
        }

        return null;
    }

    /**
     * Return the debugging detail level of this component.
     */
    public int getDebug() {
        return debug;
    }

    /**
     * Set the debugging detail level of this component.
     *
     * @param debug The new debugging detail level
     */
    public void setDebug(int debug) {
        int oldDebug = this.debug;
        this.debug = debug;
        support.firePropertyChange("debug", Integer.valueOf(oldDebug), Integer.valueOf(this.debug));
    }

    /**
     * Return descriptive information about this Service implementation and the corresponding version number, in the format
     * <code>&lt;description&gt;/&lt;version&gt;</code>.
     */
    @Override
    public String getInfo() {
        return info;
    }

    /**
     * Return the name of this Service.
     */
    @Override
    public String getName() {
        return name;
    }

    /**
     * Set the name of this Service.
     *
     * @param name The new service name
     */
    @Override
    public void setName(String name) {
        this.name = name;
    }

    /**
     * Return the <code>Server</code> with which we are associated (if any).
     */
    @Override
    public Server getServer() {
        return server;
    }

    /**
     * Set the <code>Server</code> with which we are associated (if any).
     *
     * @param server The server that owns this Service
     */
    @Override
    public void setServer(Server server) {
        this.server = server;
    }

    /**
     * Return the <code>NotificationBroadcasterSupport</code> that sends notification for this Service.
     */
    @Override
    public NotificationBroadcasterSupport getBroadcaster() {
        return broadcaster;
    }

    /**
     * Set the <code>NotificationBroadcasterSupport</code> that sends notification for this Service
     *
     * @param broadcaster The new NotificationBroadcasterSupport
     */

    @Override
    public void setBroadcaster(NotificationBroadcasterSupport broadcaster) {
        this.broadcaster = broadcaster;
    }

    // --------------------------------------------------------- Public Methods

    /**
     * Add a new Connector to the set of defined Connectors, and associate it with this Service's Container.
     *
     * @param connector The Connector to be added
     */
    @Override
    public void addConnector(Connector connector) {
        synchronized (connectorsMonitor) {
            connector.setContainer(this.container);
            connector.setService(this);
            Connector results[] = new Connector[connectors.length + 1];
            System.arraycopy(connectors, 0, results, 0, connectors.length);
            results[connectors.length] = connector;
            connectors = results;

            if (initialized) {
                try {
                    connector.initialize();
                } catch (LifecycleException e) {
                    log.log(SEVERE, "Connector.initialize", e);
                }
            }

            if (started && (connector instanceof Lifecycle)) {
                try {
                    ((Lifecycle) connector).start();
                } catch (LifecycleException e) {
                    log.log(SEVERE, "Connector.start", e);
                }
            }

            // Report this property change to interested listeners
            support.firePropertyChange("connector", null, connector);
        }

    }

    public ObjectName[] getConnectorNames() {
        return new ObjectName[connectors.length];
    }

    /**
     * Add a property change listener to this component.
     *
     * @param listener The listener to add
     */
    public void addPropertyChangeListener(PropertyChangeListener listener) {
        support.addPropertyChangeListener(listener);
    }

    /**
     * Find and return the set of Connectors associated with this Service.
     */
    @Override
    public Connector[] findConnectors() {
        return (connectors);
    }

    /**
     * Find and return the Connector associated with this Service and Connector name.
     */
    public Connector findConnector(String name) {
        for (Connector connector : connectors) {
            if (connector.getName().equals(name)) {
                return connector;
            }
        }

        return null;

    }

    /**
     * Remove the specified Connector from the set associated from this Service. The removed Connector will also be
     * disassociated from our Container.
     *
     * @param connector The Connector to be removed
     */
    @Override
    public void removeConnector(Connector connector) throws LifecycleException {
        synchronized (connectorsMonitor) {
            int j = -1;
            for (int i = 0; i < connectors.length; i++) {
                if (connector == connectors[i]) {
                    j = i;
                    break;
                }
            }

            if (j < 0) {
                return;
            }

            ((Lifecycle) connectors[j]).stop();

            int k = 0;
            Connector results[] = new Connector[connectors.length - 1];
            for (int i = 0; i < connectors.length; i++) {
                if (i != j) {
                    results[k++] = connectors[i];
                }
            }
            connectors = results;

            // Report this property change to interested listeners
            support.firePropertyChange("connector", connector, null);
        }
    }

    /**
     * Remove a property change listener from this component.
     *
     * @param listener The listener to remove
     */
    public void removePropertyChangeListener(PropertyChangeListener listener) {
        support.removePropertyChangeListener(listener);
    }

    /**
     * Return a String representation of this component.
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("StandardService[");
        sb.append(getName());
        sb.append("]");
        return sb.toString();
    }

    // ------------------------------------------------------ Lifecycle Methods

    /**
     * Add a LifecycleEvent listener to this component.
     *
     * @param listener The listener to add
     */
    @Override
    public void addLifecycleListener(LifecycleListener listener) {
        lifecycle.addLifecycleListener(listener);
    }

    /**
     * Gets the (possibly empty) list of lifecycle listeners associated with this StandardService.
     */
    @Override
    public List<LifecycleListener> findLifecycleListeners() {
        return lifecycle.findLifecycleListeners();
    }

    /**
     * Remove a LifecycleEvent listener from this component.
     *
     * @param listener The listener to remove
     */
    @Override
    public void removeLifecycleListener(LifecycleListener listener) {
        lifecycle.removeLifecycleListener(listener);
    }

    /**
     * Prepare for the beginning of active use of the public methods of this component. This method should be called before
     * any of the public methods of this component are utilized. It should also send a LifecycleEvent of type START_EVENT to
     * any registered listeners.
     *
     * @exception LifecycleException if this component detects a fatal error that prevents this component from being used
     */
    @Override
    public void start() throws LifecycleException {
        // Validate and update our current component state
        if (started) {
            log.log(INFO, SERVICE_STARTED);
        }

        if (!initialized) {
            init();
        }

        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);

        log.log(INFO, LogFacade.STARTING_SERVICE, this.name);

        lifecycle.fireLifecycleEvent(START_EVENT, null);
        started = true;

        // Start our defined Container first
        if (container != null) {
            synchronized (container) {
                if (container instanceof Lifecycle) {
                    ((Lifecycle) container).start();
                }
            }
        }

        // Start our defined Connectors second
        synchronized (connectorsMonitor) {
            for (Connector connector : connectors) {
                if (connector instanceof Lifecycle) {
                    ((Lifecycle) connector).start();
                }
            }
        }

        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
    }

    /**
     * Gracefully terminate the active use of the public methods of this component. This method should be the last one
     * called on a given instance of this component. It should also send a LifecycleEvent of type STOP_EVENT to any
     * registered listeners.
     *
     * @exception LifecycleException if this component detects a fatal error that needs to be reported
     */
    @Override
    public void stop() throws LifecycleException {
        // Validate and update our current component state
        if (!started) {
            return;
        }

        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);

        lifecycle.fireLifecycleEvent(STOP_EVENT, null);

        if (log.isLoggable(INFO)) {
            log.log(INFO, LogFacade.STOPPING_SERVICE, neutralizeForLog(this.name));
        }
        started = false;

        // Stop our defined Connectors first
        synchronized (connectorsMonitor) {
            for (Connector connector : connectors) {
                if (connector instanceof Lifecycle) {
                    ((Lifecycle) connector).stop();
                }
            }
        }

        // Stop our defined Container second
        if (container != null) {
            synchronized (container) {
                if (container instanceof Lifecycle) {
                    ((Lifecycle) container).stop();
                }
            }
        }

        // Notify our interested LifecycleListeners
        lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
    }

    /**
     * Invoke a pre-startup initialization. This is used to allow connectors to bind to restricted ports under Unix
     * operating environments.
     */
    @Override
    public void initialize() throws LifecycleException {
        // Service shouldn't be used with embedded, so it doesn't matter
        if (initialized) {
            if (log.isLoggable(INFO)) {
                log.log(INFO, LogFacade.SERVICE_HAS_BEEN_INIT);
            }
            return;
        }
        initialized = true;

        if (oname == null) {
            try {
                // Hack - Server should be deprecated...
                domain = getContainer().getName();
                oname = new ObjectName(domain + ":type=Service,serviceName=" + name);
            } catch (Exception e) {
                log.log(SEVERE, format(rb.getString(ERROR_REGISTER_SERVICE_EXCEPTION), neutralizeForLog(domain)), e);
            }

        }

        if (server == null) {
            // Register with the server
            // HACK: ServerFactory should be removed...
            ServerFactory.getServer().addService(this);
        }

        // Initialize our defined Connectors
        synchronized (connectorsMonitor) {
            for (Connector connector : connectors) {
                connector.initialize();
            }
        }
    }

    public void destroy() throws LifecycleException {
        if (started) {
            stop();
        }

        // unregister should be here probably
        if (initialized) {
            initialized = false;
        }
    }

    public void init() {
        try {
            initialize();
        } catch (Throwable t) {
            log.log(SEVERE, format(rb.getString(FAILED_SERVICE_INIT_EXCEPTION), neutralizeForLog(domain)), t);
        }
    }

    public ObjectName getObjectName() {
        return oname;
    }

    public String getDomain() {
        return domain;
    }

}