This is an automated email from the ASF dual-hosted git repository.

michaelo pushed a commit to branch 10.1.x
in repository https://gitbox.apache.org/repos/asf/tomcat.git


The following commit(s) were added to refs/heads/10.1.x by this push:
     new 966ba70198 Add ContextNamingInfoListener
966ba70198 is described below

commit 966ba701982d2779bed3246adc4e48b70971400b
Author: Michael Osipov <micha...@apache.org>
AuthorDate: Thu Jun 8 12:09:15 2023 +0200

    Add ContextNamingInfoListener
    
    A listener which creates context naming information environment entries.
---
 .../catalina/core/ContextNamingInfoListener.java   | 121 +++++++++++++++++++++
 .../apache/catalina/core/LocalStrings.properties   |   3 +
 .../core/TestContextNamingInfoListener.java        | 119 ++++++++++++++++++++
 webapps/docs/changelog.xml                         |   5 +
 webapps/docs/config/listeners.xml                  |  27 +++++
 5 files changed, 275 insertions(+)

diff --git a/java/org/apache/catalina/core/ContextNamingInfoListener.java 
b/java/org/apache/catalina/core/ContextNamingInfoListener.java
new file mode 100644
index 0000000000..cf0db7f8ed
--- /dev/null
+++ b/java/org/apache/catalina/core/ContextNamingInfoListener.java
@@ -0,0 +1,121 @@
+/*
+ * 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.core;
+
+import org.apache.catalina.Context;
+import org.apache.catalina.Lifecycle;
+import org.apache.catalina.LifecycleEvent;
+import org.apache.catalina.LifecycleListener;
+import org.apache.juli.logging.Log;
+import org.apache.juli.logging.LogFactory;
+import org.apache.tomcat.util.descriptor.web.ContextEnvironment;
+import org.apache.tomcat.util.res.StringManager;
+
+/**
+ *  Implementation of {@code LifecycleListener} that will create context 
naming information
+ *  environment entries.
+ * <p>
+ * This listener must only be nested within {@link Context} elements.
+ * <p>
+ * The following entries will be added to the initial context ({@code 
java:comp/env} implied):
+ * <ul>
+ * <li>Path: {@code context/path} from {@link Context#getPath()}</li>
+ * <li>Encoded Path: {@code context/encodedPath} from {@link 
Context#getEncodedPath()}</li>
+ * <li>Webapp Version: {@code context/webappVersion} from {@link 
Context#getWebappVersion()}</li>
+ * <li>Name: {@code context/name} from {@link Context#getName()}</li>
+ * <li>Base Name: {@code context/baseName} from {@link 
Context#getBaseName()}</li>
+ * <li>Display Name: {@code context/displayName} from {@link 
Context#getDisplayName()}</li>
+ * </ul>
+ * <p>
+ * See the <a 
href="https://tomcat.apache.org/tomcat-10.1-doc/config/context.html#Naming";>Tomcat
+ * documentation</a> for more details on the values.
+ */
+public class ContextNamingInfoListener implements LifecycleListener {
+
+    private static final String PATH_ENTRY_NAME = "context/path";
+    private static final String ENCODED_PATH_ENTRY_NAME = 
"context/encodedPath";
+    private static final String WEBAPP_VERSION_ENTRY_NAME = 
"context/webappVersion";
+    private static final String NAME_ENTRY_NAME = "context/name";
+    private static final String BASE_NAME_ENTRY_NAME = "context/baseName";
+    private static final String DISPLAY_NAME_ENTRY_NAME = 
"context/displayName";
+
+    private static final Log log = 
LogFactory.getLog(ContextNamingInfoListener.class);
+    /**
+     * The string manager for this package.
+     */
+    private static final StringManager sm = 
StringManager.getManager(ContextNamingInfoListener.class);
+
+    private boolean emptyOnRoot = true;
+
+    /**
+     * Sets whether for the root context {@code context/path} and {@code 
context/encodedPath} will
+     * contain {@code "/"} and {@code context/name} will contain {@code 
"ROOT"} with a version, if any.
+     *
+     * @param emptyOnRoot whether paths and name for root context shall be 
empty
+     */
+    public void setEmptyOnRoot(boolean emptyOnRoot) {
+        this.emptyOnRoot = emptyOnRoot;
+    }
+
+    /**
+     * Gets whether paths and name for the root context will be empty.
+     *
+     * @return indicator whether paths and name for the root context will be 
empty
+     */
+    public boolean isEmptyOnRoot() {
+        return emptyOnRoot;
+    }
+
+    @Override
+    public void lifecycleEvent(LifecycleEvent event) {
+        if (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) {
+            if (!(event.getLifecycle() instanceof Context)) {
+                log.warn(sm.getString("listener.notContext", 
event.getLifecycle().getClass().getSimpleName()));
+                return;
+            }
+            Context context = (Context) event.getLifecycle();
+            String path = context.getPath();
+            String encodedPath = context.getEncodedPath();
+            String name = context.getName();
+
+            if (!emptyOnRoot && path.isEmpty()) {
+                path = encodedPath = "/";
+                name = "ROOT" + name;
+            }
+
+            addEnvEntry(context, PATH_ENTRY_NAME, path);
+            addEnvEntry(context, ENCODED_PATH_ENTRY_NAME, encodedPath);
+            addEnvEntry(context, WEBAPP_VERSION_ENTRY_NAME, 
context.getWebappVersion());
+            addEnvEntry(context, NAME_ENTRY_NAME, name);
+            addEnvEntry(context, BASE_NAME_ENTRY_NAME, context.getBaseName());
+            addEnvEntry(context, DISPLAY_NAME_ENTRY_NAME, 
context.getDisplayName());
+        }
+    }
+
+    private void addEnvEntry(Context context, String name, String value) {
+        ContextEnvironment ce = new ContextEnvironment();
+        ce.setName(name);
+        ce.setOverride(true);
+        ce.setType("java.lang.String");
+        ce.setValue(value);
+        if (log.isDebugEnabled()) {
+            log.info(sm.getString("contextNamingInfoListener.envEntry",name, 
value));
+        }
+        context.getNamingResources().addEnvironment(ce);
+    }
+
+}
diff --git a/java/org/apache/catalina/core/LocalStrings.properties 
b/java/org/apache/catalina/core/LocalStrings.properties
index afc4812915..c5ab4a3506 100644
--- a/java/org/apache/catalina/core/LocalStrings.properties
+++ b/java/org/apache/catalina/core/LocalStrings.properties
@@ -124,6 +124,8 @@ containerBase.realm.stop=Error stopping old realm
 containerBase.threadedStartFailed=A child container failed during start
 containerBase.threadedStopFailed=A child container failed during stop
 
+contextNamingInfoListener.envEntry=Adding context env entry [{0}] with value 
[{1}]
+
 defaultInstanceManager.invalidAnnotation=Invalid [{0}] annotation
 defaultInstanceManager.invalidInjection=Invalid method resource injection 
annotation
 defaultInstanceManager.postConstructNotFound=Post construct method [{0}] for 
class [{1}] is declared in deployment descriptor but cannot be found
@@ -145,6 +147,7 @@ jniLifecycleListener.missingPathOrName=One of libraryName 
or libraryPath must be
 
 jreLeakListener.classToInitializeFail=Failed to load class [{0}] during Tomcat 
start to prevent possible memory leaks.
 
+listener.notContext=This listener must only be nested within Context elements, 
but is in [{0}].
 listener.notServer=This listener must only be nested within Server elements, 
but is in [{0}].
 
 naming.addEnvEntry=Adding environment entry [{0}]
diff --git a/test/org/apache/catalina/core/TestContextNamingInfoListener.java 
b/test/org/apache/catalina/core/TestContextNamingInfoListener.java
new file mode 100644
index 0000000000..875d0a574f
--- /dev/null
+++ b/test/org/apache/catalina/core/TestContextNamingInfoListener.java
@@ -0,0 +1,119 @@
+/*
+ *  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.core;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import org.apache.catalina.Context;
+import org.apache.catalina.LifecycleState;
+import org.apache.catalina.deploy.NamingResourcesImpl;
+import org.apache.catalina.startup.Tomcat;
+import org.apache.catalina.startup.TomcatBaseTest;
+import org.apache.catalina.util.ContextName;
+import org.apache.tomcat.util.descriptor.web.ContextEnvironment;
+
+@RunWith(Parameterized.class)
+public class TestContextNamingInfoListener extends TomcatBaseTest {
+
+    @Parameterized.Parameters(name = "{index}: contextPath[{0}], 
webappVersion[{1}], displayName[{2}], emptyOnRoot[{3}]")
+    public static Collection<Object[]> parameters() {
+        List<Object[]> parameterSets = new ArrayList<>();
+
+        parameterSets.add(new Object[] { "", "", null,  Boolean.FALSE, "/", 
"/", "ROOT" });
+        parameterSets.add(new Object[] { "", "42", null,  Boolean.FALSE, "/", 
"/", "ROOT##42" });
+        parameterSets.add(new Object[] { "", "", null,  Boolean.TRUE, "", "", 
"" });
+        parameterSets.add(new Object[] { "", "42", null,  Boolean.TRUE, "", 
"", "##42" });
+        for (Boolean b: Arrays.asList(Boolean.FALSE, Boolean.TRUE)) {
+            parameterSets.add(new Object[] { "/foo", "", null,  b, "/foo", 
"/foo", "/foo" });
+            parameterSets.add(new Object[] { "/foo", "", "My Foo Webapp",  b, 
"/foo", "/foo", "/foo" });
+            parameterSets.add(new Object[] { "/foo", "42", "My Foo Webapp",  
b, "/foo", "/foo", "/foo##42" });
+            parameterSets.add(new Object[] { "/foo/bar", "", null,  b, 
"/foo/bar", "/foo/bar", "/foo/bar" });
+            parameterSets.add(new Object[] { "/foo/bar", "", "My Foobar 
Webapp",  b, "/foo/bar", "/foo/bar", "/foo/bar" });
+            parameterSets.add(new Object[] { "/foo/bar", "42", "My Foobar 
Webapp",  b, "/foo/bar", "/foo/bar", "/foo/bar##42" });
+            parameterSets.add(new Object[] { 
"/\u0444\u0443/\u0431\u0430\u0440", "", "\u041C\u043E\u0439 
\u0424\u0443\u0431\u0430\u0440 \u0412\u0435\u0431\u0430\u043F\u043F",  b, 
"/\u0444\u0443/\u0431\u0430\u0440", "/%D1%84%D1%83/%D0%B1%D0%B0%D1%80", 
"/\u0444\u0443/\u0431\u0430\u0440" });
+            parameterSets.add(new Object[] { 
"/\u0444\u0443/\u0431\u0430\u0440", "42", "\u041C\u043E\u0439 
\u0424\u0443\u0431\u0430\u0440 \u0412\u0435\u0431\u0430\u043F\u043F",  b, 
"/\u0444\u0443/\u0431\u0430\u0440", "/%D1%84%D1%83/%D0%B1%D0%B0%D1%80", 
"/\u0444\u0443/\u0431\u0430\u0440##42" });
+        }
+
+        return parameterSets;
+    }
+
+    @Parameter(0)
+    public String contextPath;
+    @Parameter(1)
+    public String webappVersion;
+    @Parameter(2)
+    public String displayName;
+    @Parameter(3)
+    public Boolean emptyOnRoot;
+    @Parameter(4)
+    public String expectedContextPath;
+    @Parameter(5)
+    public String expectedEncodedContextPath;
+    @Parameter(6)
+    public String expectedName;
+
+    @Test
+    public void testListener() throws Exception {
+        Tomcat tomcat = getTomcatInstance();
+
+        // No file system docBase required
+        ContextName cn = new ContextName(contextPath, webappVersion);
+        Context ctx = tomcat.addContext(cn.getPath(), null);
+        ctx.setName(cn.getName());
+        ctx.setWebappVersion(cn.getVersion());
+        ctx.setDisplayName(displayName);
+
+        // Enable JNDI - it is disabled by default
+        tomcat.enableNaming();
+
+        ContextNamingInfoListener listener = new ContextNamingInfoListener();
+        listener.setEmptyOnRoot(emptyOnRoot);
+
+        ctx.addLifecycleListener(listener);
+
+        tomcat.start();
+
+        Assert.assertEquals(LifecycleState.STARTED, ctx.getState());
+
+        NamingResourcesImpl namingResources = ctx.getNamingResources();
+        ContextEnvironment pathEnv = 
namingResources.findEnvironment("context/path");
+        ContextEnvironment encodedPathEnv = 
namingResources.findEnvironment("context/encodedPath");
+        ContextEnvironment webappVersionEnv = 
namingResources.findEnvironment("context/webappVersion");
+        ContextEnvironment nameEnv = 
namingResources.findEnvironment("context/name");
+        ContextEnvironment baseNameEnv = 
namingResources.findEnvironment("context/baseName");
+        ContextEnvironment displayNameEnv = 
namingResources.findEnvironment("context/displayName");
+
+        Assert.assertEquals(expectedContextPath, pathEnv.getValue());
+        Assert.assertEquals(expectedEncodedContextPath, 
encodedPathEnv.getValue());
+        Assert.assertEquals(ctx.getWebappVersion(), 
webappVersionEnv.getValue());
+        Assert.assertEquals(expectedName, nameEnv.getValue());
+        Assert.assertEquals(ctx.getBaseName(), baseNameEnv.getValue());
+        Assert.assertEquals(ctx.getDisplayName(), displayNameEnv.getValue());
+
+        tomcat.stop();
+    }
+
+}
diff --git a/webapps/docs/changelog.xml b/webapps/docs/changelog.xml
index dda15a61fc..c6ea70d9ef 100644
--- a/webapps/docs/changelog.xml
+++ b/webapps/docs/changelog.xml
@@ -107,6 +107,11 @@
 <section name="Tomcat 10.1.11 (schultz)" rtext="in development">
   <subsection name="Catalina">
     <changelog>
+      <add>
+        Add <code>org.apache.catalina.core.ContextNamingInfoListener</code>,
+        a listener which creates context naming information environment 
entries.
+        (michaelo)
+      </add>
       <fix>
         Fix an edge case where intra-web application symlinks would be followed
         if the web applications were deliberately crafted to allow it even when
diff --git a/webapps/docs/config/listeners.xml 
b/webapps/docs/config/listeners.xml
index 1495915373..9f0dd02eae 100644
--- a/webapps/docs/config/listeners.xml
+++ b/webapps/docs/config/listeners.xml
@@ -145,6 +145,33 @@
 
   </subsection>
 
+  <subsection name="Context Naming Info Listener - 
org.apache.catalina.core.ContextNamingInfoListener">
+
+    <p>The <strong>Context Naming Info Listener</strong> adds the following
+    environment entries (<code>java:comp/env</code> implied) from the
+    <a href="context.html">Context</a>: <code>context/path</code>,
+    <code>context/encodedPath</code>, <code>context/webappVersion</code>,
+    <code>context/name</code>, <code>context/baseName</code>,
+    <code>context/displayName</code>.</p>
+
+    <p>This listener must only be nested within
+    <a href="context.html">Context</a> elements.</p>
+
+    <p>The following additional attributes are supported by the
+    <strong>Context Naming Info Listener</strong>:</p>
+
+    <attributes>
+      <attribute name="emptyOnRoot" required="false">
+        <p>Whether for the root context <code>context/path</code> and
+        <code>context/encodedPath</code> will contain <code>"/"</code> and
+        <code>context/name</code> will contain <code>"ROOT"</code> with a 
version,
+        if any.</p>
+        <p>The default value is <code>true</code>.</p>
+      </attribute>
+    </attributes>
+
+  </subsection>
+
   <subsection name="Global Resources Lifecycle Listener - 
org.apache.catalina.mbeans.GlobalResourcesLifecycleListener">
 
     <p>The <strong>Global Resources Lifecycle Listener</strong> initializes the


---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscr...@tomcat.apache.org
For additional commands, e-mail: dev-h...@tomcat.apache.org

Reply via email to