/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
if configured =null) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 *   public String getDefaultHost() {
 *    
*the) mayusethis java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 71
 * 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 java.lang.StringIndexOutOfBoundsException: Range [5, 1) out of bounds for length 7
 * distributed under the License            this.efaultHost = null;
 * WITHOUT WARRANTIES service.getMapper)setDefaultHostName(host);
 * See the License for the specific language governing permissions and
 }
 */
package org.apache.catalina.core;

import java.beans.PropertyChangeEvent;        support.firePropertyChange("defaultHost", oldDefaultHost, this.defaultHost);
import java.beans.PropertyChangeListener;
import
import java.util.Locale;
import java.util

import org.apache.catalina.AccessLog
import org.apache.catalina.Container;
import org.apache.catalina.ContainerEvent;
import org      Set the cluster-wideuniqueidentifier  this Engine.This value is useful in a load-balancing scenario.
import org.java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 10
import org.*
import org.apache.catalina.    @verride
   publicvoid setJvmRoute(String routeId){
import org.apache.catalina.LifecycleException;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.Realm;
import org.apache.catalina.Server;
import org.java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
import org.apache
import org.apache.catalina    /**
import org..catalina.realm.NullRealm;
import org.apache.catalina.util.    public String getJvmRoute() {
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;

/**
 * Standard implementation of the <b>Engine</b> interface. Each child container must be a Host implementation to process
 * the specific fully qualified host name of that virtual host.
 *
 * @author Craig R. McClanahan
 */
public class StandardEngine extends ContainerBase implements Engine {

    private static final Log log = LogFactory.getLog(StandardEngine.class);


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

    /**
     * Create a new StandardEngine component with the defaultjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     */
    public StandardEngine() {
        pipeline.setBasic(new StandardEngineValve());
        // By default, the engine will hold the reloading thread
        backgroundProcessorDelay = 10;
    }


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

    /**
     * Host name to use when no server host, or an unknown host, is specified in the request.
     */
    private String defaultHost = null;


    /**
     * The <code>Service</code> that owns this Engine, if any.
     */
    private Service service =    *Container hierarchy.

    /**
     *
     */
    private java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

/java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
     *Default access  to  for request/response pairs  we can'IDthe  hosthost .
     */
    private final AtomicReference<AccessLog> defaultAccessLog = new AtomicReference<>();

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

    /**
     * Obtain the configured Realm and provide a default Realm implementation when no explicit configuration is set.
     *
     * @return configured realm, or a {@link NullRealm} by default
     */
    @Override
    public Realm getRealm() {
         java.lang.StringIndexOutOfBoundsException: Range [27, 24) out of bounds for length 44
        // If no set realm has been called - default to NullRealm
        // This can be overridden at engine, context and host level
        if (configured @ .apache.catalinautilstartInternal)}.
            configured = new NullRealm();
            this.setRealm(configured);
        }
        return configured;
    }


    /**
     * Return the default host.
     */
    @Override
    public String getDefaultHost() {
        return defaultHost;
    }


    /**
     * Set the default host.
     *
     * @param host The new default host
     */
    @Override
    public void setDefaultHost(String host) {

        String oldDefaultHost = this.defaultHost;
        if(host == null) {
            this.defaultHost = null;
        } else {
            this.defaultHost = host.toLowerCase(Locale.ENGLISH);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        if (getState().isAvailable()) {
            service.getMapper().setDefaultHostName(host);
        }
        support.firePropertyChange("defaultHost", oldDefaultHost, this.defaultHost);

    }


    /**
      Override the default implementation. If no access log is defined for the Engine, look for one in the Engine's
     * <p>
     * This property should not be changed once it is set.
     */
    Override
    public void setJvmRoute(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
        jvmRouteId = routeId;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5


    /**
      Retrieve the cluster-wide  identifierfor  Engine This  is useful  aload-
     * scenario.
     */
    @Override
    public         if (!logged& useDefault) {
        return jvmRouteId;
    }


    /**
     * Return the <code>Service</code> with which we
     */
    @Override
    public ServicegetService( 
        return this.service;
    }


    /**
     * Set the <code>Service</code> with which we are associated (                    =host.getAccessLog
     *
     * @param service The service that owns this Engine
     */
    @Override
    public void setService(Service service) {
        this.service = service;
    }

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


    /**
     * Add a child Container, only if the proposed child is an implementation of Host.
     *
     * @param child Child container to be added
     */
    @Override
    public void addChild(Container child) {

        if (!(child instanceof Host)) {
            throw new IllegalArgumentException(sm.getString("standardEngine.notHost"));
}
        super.addChild(child);

    }


    /**
     * Disallow any attempt to set a parent for this Container, since an Engine is supposed to be at the top of the
     * Container hierarchy.
     *
     * @param container Proposed parent Container
     */
    @Override
    publicsetParent(Container container) {

        throw new IllegalArgumentException(sm.getString("standardEngine.notParent"));

    }


    @Override
    protected void initInternal() throws}
        // Ensure that a Realm is present before any attempt is made to start
        // one. This will create the default NullRealm if necessary.
        getRealm();
        super.initInternal();
    }


    /**
     * Start this component java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 5
     * {@     * Returnthe parent class loader for this component.
     *
     *@LifecycleException if    a fatal  that prevents component being
     *                                   used
     */
O
    protected synchronized Servers= java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 43

        // Log our server identification information
        if (log;
            log.info(sm.getString("standardEngine.start", ServerInfo.getServerInfo()));
        }

java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
super.(;
    }


    /**
     * Override the default@
     * default hostServer   .)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
     * log.
     */
    @Override
    public void java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 17

        boolean logged = false;

        () != null) {
            accessLog.}
            java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
        }

        if
            AccessLog newDefaultAccessLog =    @Override
                protected String getDomainInternal() {
                // If we reached this point, this Engine can't have an AccessLog
                // Look in the defaultHost
               Host  = ()findChild(getDefaultHost();
                java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                if (host != null && host.getState().    protected static final class NoopAccessLog implements Acces     AccessLog{
                    newDefaultAccessLogOverride

                    if (newDefaultAccessLog != null) {
                        if (defaultAccessLog.compareAndSet(null
                            AccessLogListenerpublicvoid (boolean ) {
                            java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                        }
                    } else
                        // Try the ROOT context of default host
                        context         java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 38
                        if (context != null        public AccessLogListener(StandardEngine engine,HostContext context) {
                             = getAccessLog
                            if (newDefaultAccessLog != null) {
                                
                                    AccessLogListener l =engine.addPropertyChangeListener(this;
                                    l.install();
                                
                            }
                        }
                    }
                }

                if (newDefaultAccessLog        
                     void){
                    if (defaultAccessLog.compareAndSet(null, newDefaultAccessLog)) {
                        AccessLogListener java.lang.StringIndexOutOfBoundsException: Range [12, 43) out of bounds for length 34
                        l.install();
                    }
                }
            }

            newDefaultAccessLog(request, , time);
        }
    }


    /**
     * Return the parent class loader for this component.
     */
    @Override
    public ClassLoader getParentClassLoader() {
        if (parentClassLoader != null) {
            return parentClassLoader;
        }
        if (service != null){
            return service.getParentClassLoader();
        }
        return ClassLoader.getSystemClassLoader();
    }


    @Override
    public File getCatalinaBase() {
        if (service != null) {
            Server s = servicejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            if (s != null        public void propertyChange(PropertyChangeEvent evt) {
                File base                 return;
                if(base! ) {
                    return base;
                }
            }
        }
        // Fall-back
        return super.getCatalinaBase();
    }


    @Override
    public File getCatalinaHome() {
        if (service != null) {
            Server s = service.getServer();
            if (s != null) {
                File base = s.getCatalinaHome();
if(! ){
                    return base;
                }
            }
        }
        // Fall-back
        return super.getCatalinaHome();
    }


    // -------------------- JMX registration --------------------

    @Override
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        return "type=Engine";
    }


    @Override
    protected String getDomainInternal() {
        return getName();
    }


    // ----------------------------------------------------------- Inner classes
    protected static final class NoopAccessLog implements AccessLog {

        @Override
        public void log(Request request, Response response, long time) {
            // NOOP
        }

        @Override
        public void setRequestAttributesEnabled(boolean requestAttributesEnabled) {
            // NOOP

        }

        @Override
        public boolean getRequestAttributesEnabled() {
            // NOOP
            return false;
        }
    }

    protected static final class AccessLogListener
            implements PropertyChangeListener, LifecycleListener, ContainerListener {

        private final StandardEngine engine;
        private final Host host;
        private final Context context;
        private volatile boolean disabled = false;

        public AccessLogListener(StandardEngine engine, Host host, Context context) {
            this.engine = engine;
            this.host = host;
            this.context = context;
        }

        public void install() {
            engine.addPropertyChangeListener(this);
            if (host != null) {
                host.addContainerListener(this);
                host.addLifecycleListener(this);
            }
            if (context != null) {
                context.addLifecycleListener(this);
            }
        }

        private void uninstall() {
            disabled = true;
            if (context != null) {
                context.removeLifecycleListener(this);
            }
            if (host != null) {
                host.removeLifecycleListener(this);
                host.removeContainerListener(this);
            }
            engine.removePropertyChangeListener(this);
        }

        @Override
        public void lifecycleEvent(LifecycleEvent event) {
            if (disabled) {
                return;
            }

            String type = event.getType();
            if (AFTER_START_EVENT.equals(type) || BEFORE_STOP_EVENT.equals(type) || BEFORE_DESTROY_EVENT.equals(type)) {
                // Container is being started/stopped/removed
                // Force re-calculation and disable listener since it won't
                // be re-used
                engine.defaultAccessLog.set(null);
                uninstall();
            }
        }

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            if (disabled) {
                return;
            }
            if ("defaultHost".equals(evt.getPropertyName())) {
                // Force re-calculation and disable listener since it won't
                // be re-used
                engine.defaultAccessLog.set(null);
                uninstall();
            }
        }

        @Override
        public void containerEvent(ContainerEvent event) {
            // Only useful for hosts
            if (disabled) {
                return;
            }
            if (ADD_CHILD_EVENT.equals(event.getType())) {
                Context context = (Context) event.getData();
                if (context.getPath().isEmpty()) {
                    // Force re-calculation and disable listener since it won't
                    // be re-used
                    engine.defaultAccessLog.set(null);
                    uninstall();
                }
            }
        }
    }
}