init

java/org/apache/catalina/storeconfig/StandardContextSF.java

@@ -0,0 +1,369 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.storeconfig;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.catalina.Container;
+import org.apache.catalina.Context;
+import org.apache.catalina.Engine;
+import org.apache.catalina.Host;
+import org.apache.catalina.LifecycleListener;
+import org.apache.catalina.Loader;
+import org.apache.catalina.Manager;
+import org.apache.catalina.Realm;
+import org.apache.catalina.Valve;
+import org.apache.catalina.WebResourceRoot;
+import org.apache.catalina.core.StandardContext;
+import org.apache.catalina.core.ThreadLocalLeakPreventionListener;
+import org.apache.catalina.deploy.NamingResourcesImpl;
+import org.apache.catalina.util.ContextName;
+import org.apache.juli.logging.Log;
+import org.apache.juli.logging.LogFactory;
+import org.apache.tomcat.JarScanner;
+import org.apache.tomcat.util.descriptor.web.ApplicationParameter;
+import org.apache.tomcat.util.http.CookieProcessor;
+
+/**
+ * Store server.xml Context element with all children
+ * <ul>
+ * <li>Store all context at server.xml</li>
+ * <li>Store existing app.xml context a conf/enginename/hostname/app.xml</li>
+ * <li>Store with backup</li>
+ * </ul>
+ */
+public class StandardContextSF extends StoreFactoryBase {
+
+    private static Log log = LogFactory.getLog(StandardContextSF.class);
+
+    /**
+     * Store a Context as Separate file as configFile value from context exists.
+     * filename can be relative to catalina.base.
+     *
+     * @see org.apache.catalina.storeconfig.IStoreFactory#store(java.io.PrintWriter,
+     *      int, java.lang.Object)
+     */
+    @Override
+    public void store(PrintWriter aWriter, int indent, Object aContext)
+            throws Exception {
+
+        if (aContext instanceof StandardContext) {
+            StoreDescription desc = getRegistry().findDescription(
+                    aContext.getClass());
+            if (desc.isStoreSeparate()) {
+                URL configFile = ((StandardContext) aContext)
+                        .getConfigFile();
+                if (configFile != null) {
+                    if (desc.isExternalAllowed()) {
+                        if (desc.isBackup())
+                            storeWithBackup((StandardContext) aContext);
+                        else
+                            storeContextSeparate(aWriter, indent,
+                                    (StandardContext) aContext);
+                        return;
+                    }
+                } else if (desc.isExternalOnly()) {
+                    // Set a configFile so that the configuration is actually saved
+                    Context context = ((StandardContext) aContext);
+                    Host host = (Host) context.getParent();
+                    File configBase = host.getConfigBaseFile();
+                    ContextName cn = new ContextName(context.getName(), false);
+                    String baseName = cn.getBaseName();
+                    File xml = new File(configBase, baseName + ".xml");
+                    context.setConfigFile(xml.toURI().toURL());
+                    if (desc.isBackup())
+                        storeWithBackup((StandardContext) aContext);
+                    else
+                        storeContextSeparate(aWriter, indent,
+                                (StandardContext) aContext);
+                    return;
+                }
+            }
+        }
+        super.store(aWriter, indent, aContext);
+
+    }
+
+    /**
+     * Store a Context without backup add separate file or when configFile =
+     * null a aWriter.
+     *
+     * @param aWriter Current output writer
+     * @param indent Indentation level
+     * @param aContext The context which will be stored
+     * @throws Exception Configuration storing error
+     */
+    protected void storeContextSeparate(PrintWriter aWriter, int indent,
+            StandardContext aContext) throws Exception {
+        URL configFile = aContext.getConfigFile();
+        if (configFile != null) {
+            File config = new File(configFile.toURI());
+            if (!config.isAbsolute()) {
+                config = new File(System.getProperty("catalina.base"),
+                        config.getPath());
+            }
+            if( (!config.isFile()) || (!config.canWrite())) {
+                log.error("Cannot write context output file at "
+                            + configFile + ", not saving.");
+                throw new IOException("Context save file at "
+                                      + configFile
+                                      + " not a file, or not writable.");
+            }
+            if (log.isInfoEnabled())
+                log.info("Store Context " + aContext.getPath()
+                        + " separate at file " + config);
+            try (FileOutputStream fos = new FileOutputStream(config);
+                    PrintWriter writer = new PrintWriter(new OutputStreamWriter(
+                            fos , getRegistry().getEncoding()))) {
+                storeXMLHead(writer);
+                super.store(writer, -2, aContext);
+            }
+        } else {
+            super.store(aWriter, indent, aContext);
+        }
+    }
+
+    /**
+     * Store the Context with a Backup.
+     *
+     * @param aContext The context which will be stored
+     * @throws Exception Configuration storing error
+     */
+    protected void storeWithBackup(StandardContext aContext) throws Exception {
+        StoreFileMover mover = getConfigFileWriter(aContext);
+        if (mover != null) {
+            // Bugzilla 37781 Check to make sure we can write this output file
+            if ((mover.getConfigOld() == null)
+                    || (mover.getConfigOld().isDirectory())
+                    || (mover.getConfigOld().exists() &&
+                            !mover.getConfigOld().canWrite())) {
+                log.error("Cannot move orignal context output file at "
+                        + mover.getConfigOld());
+                throw new IOException("Context original file at "
+                        + mover.getConfigOld()
+                        + " is null, not a file or not writable.");
+            }
+            File dir = mover.getConfigSave().getParentFile();
+            if (dir != null && dir.isDirectory() && (!dir.canWrite())) {
+                log.error("Cannot save context output file at "
+                        + mover.getConfigSave());
+                throw new IOException("Context save file at "
+                        + mover.getConfigSave() + " is not writable.");
+            }
+            if (log.isInfoEnabled())
+                log.info("Store Context " + aContext.getPath()
+                        + " separate with backup (at file "
+                        + mover.getConfigSave() + " )");
+
+            try (PrintWriter writer = mover.getWriter()) {
+                storeXMLHead(writer);
+                super.store(writer, -2, aContext);
+            }
+            mover.move();
+        }
+    }
+
+    /**
+     * Get explicit writer for context (context.getConfigFile()).
+     *
+     * @param context The context which will be stored
+     * @return The file mover
+     * @throws Exception Error getting a writer for the configuration file
+     */
+    protected StoreFileMover getConfigFileWriter(Context context)
+            throws Exception {
+        URL configFile = context.getConfigFile();
+        StoreFileMover mover = null;
+        if (configFile != null) {
+            File config = new File(configFile.toURI());
+            if (!config.isAbsolute()) {
+                config = new File(System.getProperty("catalina.base"),
+                        config.getPath());
+            }
+            // Open an output writer for the new configuration file
+            mover = new StoreFileMover("", config.getCanonicalPath(),
+                    getRegistry().getEncoding());
+        }
+        return mover;
+    }
+
+    /**
+     * Store the specified context element children.
+     *
+     * @param aWriter Current output writer
+     * @param indent Indentation level
+     * @param aContext Context to store
+     * @param parentDesc The element description
+     * @throws Exception Configuration storing error
+     */
+    @Override
+    public void storeChildren(PrintWriter aWriter, int indent, Object aContext,
+            StoreDescription parentDesc) throws Exception {
+        if (aContext instanceof StandardContext) {
+            StandardContext context = (StandardContext) aContext;
+            // Store nested <Listener> elements
+            LifecycleListener listeners[] = context.findLifecycleListeners();
+            ArrayList<LifecycleListener> listenersArray = new ArrayList<>();
+            for (LifecycleListener listener : listeners) {
+                if (!(listener instanceof ThreadLocalLeakPreventionListener)) {
+                    listenersArray.add(listener);
+                }
+            }
+            storeElementArray(aWriter, indent, listenersArray.toArray());
+
+            // Store nested <Valve> elements
+            Valve valves[] = context.getPipeline().getValves();
+            storeElementArray(aWriter, indent, valves);
+
+            // Store nested <Loader> elements
+            Loader loader = context.getLoader();
+            storeElement(aWriter, indent, loader);
+
+            // Store nested <Manager> elements
+            if (context.getCluster() == null || !context.getDistributable()) {
+                Manager manager = context.getManager();
+                storeElement(aWriter, indent, manager);
+            }
+
+            // Store nested <Realm> element
+            Realm realm = context.getRealm();
+            if (realm != null) {
+                Realm parentRealm = null;
+                // @TODO is this case possible?
+                if (context.getParent() != null) {
+                    parentRealm = context.getParent().getRealm();
+                }
+                if (realm != parentRealm) {
+                    storeElement(aWriter, indent, realm);
+                }
+            }
+            // Store nested resources
+            WebResourceRoot resources = context.getResources();
+            storeElement(aWriter, indent, resources);
+
+            // Store nested <WrapperListener> elements
+            String wLifecycles[] = context.findWrapperLifecycles();
+            getStoreAppender().printTagArray(aWriter, "WrapperListener",
+                    indent + 2, wLifecycles);
+            // Store nested <WrapperLifecycle> elements
+            String wListeners[] = context.findWrapperListeners();
+            getStoreAppender().printTagArray(aWriter, "WrapperLifecycle",
+                    indent + 2, wListeners);
+
+            // Store nested <Parameter> elements
+            ApplicationParameter[] appParams = context
+                    .findApplicationParameters();
+            storeElementArray(aWriter, indent, appParams);
+
+            // Store nested naming resources elements (EJB,Resource,...)
+            NamingResourcesImpl nresources = context.getNamingResources();
+            storeElement(aWriter, indent, nresources);
+
+            // Store nested watched resources <WatchedResource>
+            String[] wresources = context.findWatchedResources();
+            wresources = filterWatchedResources(context, wresources);
+            getStoreAppender().printTagArray(aWriter, "WatchedResource",
+                    indent + 2, wresources);
+
+            // Store nested <JarScanner> elements
+            JarScanner jarScanner = context.getJarScanner();
+            storeElement(aWriter, indent, jarScanner);
+
+            // Store nested <CookieProcessor> elements
+            CookieProcessor cookieProcessor = context.getCookieProcessor();
+            storeElement(aWriter, indent, cookieProcessor);
+        }
+    }
+
+    /**
+     * Return a File object representing the "configuration root" directory for
+     * our associated Host.
+     * @param context The context instance
+     * @return a file to the configuration base path
+     */
+    protected File configBase(Context context) {
+
+        File file = new File(System.getProperty("catalina.base"), "conf");
+        Container host = context.getParent();
+
+        if (host instanceof Host) {
+            Container engine = host.getParent();
+            if (engine instanceof Engine) {
+                file = new File(file, engine.getName());
+            }
+            file = new File(file, host.getName());
+            try {
+                file = file.getCanonicalFile();
+            } catch (IOException e) {
+                log.error(e);
+            }
+        }
+        return file;
+
+    }
+
+    /**
+     * Filter out the default watched resources, to remove standard ones.
+     *
+     * @param context The context instance
+     * @param wresources The raw watched resources list
+     * @return The filtered watched resources
+     * @throws Exception Configuration storing error
+     * TODO relative watched resources
+     * TODO absolute handling configFile
+     * TODO Filename case handling for Windows?
+     * TODO digester variable substitution $catalina.base, $catalina.home
+     */
+    protected String[] filterWatchedResources(StandardContext context,
+            String[] wresources) throws Exception {
+        File configBase = configBase(context);
+        String confContext = new File(System.getProperty("catalina.base"),
+                "conf/context.xml").getCanonicalPath();
+        String confWeb = new File(System.getProperty("catalina.base"),
+                "conf/web.xml").getCanonicalPath();
+        String confHostDefault = new File(configBase, "context.xml.default")
+                .getCanonicalPath();
+        String configFile = (context.getConfigFile() != null ? new File(context.getConfigFile().toURI()).getCanonicalPath() : null);
+        String webxml = "WEB-INF/web.xml" ;
+
+        List<String> resource = new ArrayList<>();
+        for (int i = 0; i < wresources.length; i++) {
+
+            if (wresources[i].equals(confContext))
+                continue;
+            if (wresources[i].equals(confWeb))
+                continue;
+            if (wresources[i].equals(confHostDefault))
+                continue;
+            if (wresources[i].equals(configFile))
+                continue;
+            if (wresources[i].equals(webxml))
+                continue;
+            resource.add(wresources[i]);
+        }
+        return resource.toArray(new String[resource.size()]);
+    }
+
+}