Merge remote-tracking branch 'origin/jetty-9.4.x' into jetty-10.0.x

jetty-servlet/src/main/java/org/eclipse/jetty/servlet/ServletHandler.java

@@ -128,6 +128,12 @@ public class ServletHandler extends ScopedHandler
     {
     }
 
+    @Override
+    public boolean isDumpable(Object o)
+    {
+        return !(o instanceof Holder || o instanceof BaseHolder || o instanceof FilterMapping || o instanceof ServletMapping);
+    }
+
     @Override
     public void dump(Appendable out, String indent) throws IOException
     {
@@ -216,6 +222,13 @@ public class ServletHandler extends ScopedHandler
             super.start(l);
     }
     
+    @Override
+    protected void stop(LifeCycle l) throws Exception
+    {
+        if (!(l instanceof Holder))
+            super.stop(l);
+    }
+
     @Override
     protected synchronized void doStop()
         throws Exception
@@ -251,8 +264,12 @@ public class ServletHandler extends ScopedHandler
         }
 
         //Retain only filters and mappings that were added using jetty api (ie Source.EMBEDDED)
-        _filters = (FilterHolder[])LazyList.toArray(filterHolders, FilterHolder.class);
+        FilterHolder[] fhs = (FilterHolder[])LazyList.toArray(filterHolders, FilterHolder.class);
-        _filterMappings = (FilterMapping[])LazyList.toArray(filterMappings, FilterMapping.class);
+        updateBeans(_filters, fhs);
+        _filters = fhs;
+        FilterMapping[] fms = (FilterMapping[])LazyList.toArray(filterMappings, FilterMapping.class);
+        updateBeans(_filterMappings, fms);
+        _filterMappings = fms;
 
         _matchAfterIndex = (_filterMappings == null || _filterMappings.length == 0 ? -1 : _filterMappings.length - 1);
         _matchBeforeIndex = -1;
@@ -287,8 +304,12 @@ public class ServletHandler extends ScopedHandler
         }
 
         //Retain only Servlets and mappings added via jetty apis (ie Source.EMBEDDED)
-        _servlets = (ServletHolder[])LazyList.toArray(servletHolders, ServletHolder.class);
+        ServletHolder[] shs = (ServletHolder[])LazyList.toArray(servletHolders, ServletHolder.class);
-        _servletMappings = (ServletMapping[])LazyList.toArray(servletMappings, ServletMapping.class);
+        updateBeans(_servlets, shs);
+        _servlets = shs;
+        ServletMapping[] sms = (ServletMapping[])LazyList.toArray(servletMappings, ServletMapping.class);
+        updateBeans(_servletMappings, sms);
+        _servletMappings = sms;
         
         if (_contextHandler != null)
             _contextHandler.contextDestroyed();
@@ -312,7 +333,9 @@ public class ServletHandler extends ScopedHandler
                     listenerHolders.add(listener);
             }
         }
-        _listeners = (ListenerHolder[])LazyList.toArray(listenerHolders, ListenerHolder.class);
+        ListenerHolder[] listeners = (ListenerHolder[])LazyList.toArray(listenerHolders, ListenerHolder.class);
+        updateBeans(_listeners, listeners);
+        _listeners = listeners;
 
         //will be regenerated on next start
         _filterPathMappings = null;
@@ -765,7 +788,7 @@ public class ServletHandler extends ScopedHandler
             {
                 holder.setServletHandler(this);
             }
-
+        updateBeans(_listeners,listeners);
         _listeners = listeners;
     }
 
@@ -1442,6 +1465,7 @@ public class ServletHandler extends ScopedHandler
      */
     public void setFilterMappings(FilterMapping[] filterMappings)
     {
+        updateBeans(_filterMappings,filterMappings);
         _filterMappings = filterMappings;
         if (isStarted())
             updateMappings();
@@ -1455,7 +1479,7 @@ public class ServletHandler extends ScopedHandler
             {
                 holder.setServletHandler(this);
             }
-
+        updateBeans(_filters,holders);
         _filters = holders;
         updateNameMappings();
         invalidateChainsCache();
@@ -1466,6 +1490,7 @@ public class ServletHandler extends ScopedHandler
      */
     public void setServletMappings(ServletMapping[] servletMappings)
     {
+        updateBeans(_servletMappings,servletMappings);
         _servletMappings = servletMappings;
         if (isStarted())
             updateMappings();
@@ -1484,7 +1509,7 @@ public class ServletHandler extends ScopedHandler
             {
                 holder.setServletHandler(this);
             }
-
+        updateBeans(_servlets,holders);
         _servlets = holders;
         updateNameMappings();
         invalidateChainsCache();

jetty-servlet/src/test/java/org/eclipse/jetty/servlet/ServletHandlerTest.java

@@ -18,9 +18,15 @@
 
 package org.eclipse.jetty.servlet;
 
+import java.util.ArrayList;
 import java.util.EnumSet;
+import java.util.List;
 import javax.servlet.DispatcherType;
+import javax.servlet.http.HttpSessionEvent;
+import javax.servlet.http.HttpSessionListener;
 
+import org.eclipse.jetty.http.pathmap.MappedResource;
+import org.eclipse.jetty.util.component.Container;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -656,4 +662,72 @@ public class ServletHandlerTest
         assertTrue(fh3 == mappings[5].getFilterHolder()); //isMatchAfter = true;
         assertTrue(pf == mappings[6].getFilterHolder()); //isMatchAfter = true;
     }
+    
+    @Test
+    public void testFiltersServletsListenersAsBeans() throws Exception
+    {
+        ServletContextHandler context = new ServletContextHandler();
+        
+        ServletHandler handler = context.getServletHandler();
+        
+        //test that filters, servlets and listeners are added as beans
+        //and thus reported in a Container.Listener
+        List<Object> addResults = new ArrayList<>();
+        List<Object> removeResults = new ArrayList<>();
+        handler.addEventListener(new Container.Listener()
+        {
+            @Override
+            public void beanAdded(Container parent, Object child)
+            {
+                addResults.add(child);
+            }
+
+            @Override
+            public void beanRemoved(Container parent, Object child)
+            {
+                removeResults.add(child);
+            }
+        
+        });
+
+        handler.addFilter(fh1);
+        handler.addServlet(sh1);
+        ListenerHolder lh1 = new ListenerHolder(new Source(Source.Origin.DESCRIPTOR, "foo.xml"));
+        lh1.setInstance(new HttpSessionListener()
+        {  
+            @Override
+            public void sessionDestroyed(HttpSessionEvent se)
+            {
+            }
+            
+            @Override
+            public void sessionCreated(HttpSessionEvent se)
+            {   
+            }
+        });
+        handler.addListener(lh1);
+        
+        assertTrue(addResults.contains(fh1));
+        assertTrue(addResults.contains(sh1));
+        assertTrue(addResults.contains(lh1));
+        
+        //test that servlets, filters and listeners are dumped, but
+        //not as beans
+        String dump = handler.dump();
+        dump = dump.substring(0, dump.indexOf("key:"));
+
+        assertFalse(dump.contains("+-")); //not dumped as beans
+        assertFalse(dump.contains("+=")); //not dumped as managed beans
+        assertFalse(dump.contains("+~")); //not dumped as unmanaged beans
+        assertFalse(dump.contains("+?")); //not dumped as auto beans
+
+        handler.setFilters(null);
+        handler.setServlets(null);
+        handler.setListeners(null);
+
+        //check they're removed as beans
+        assertTrue(removeResults.contains(fh1));
+        assertTrue(removeResults.contains(sh1));
+        assertTrue(removeResults.contains(lh1));
+    }
 }

jetty-util/src/main/java/org/eclipse/jetty/util/component/ContainerLifeCycle.java

@@ -80,7 +80,7 @@ import org.slf4j.LoggerFactory;
  * </pre>
  */
 @ManagedObject("Implementation of Container and LifeCycle")
-public class ContainerLifeCycle extends AbstractLifeCycle implements Container, Destroyable, Dumpable
+public class ContainerLifeCycle extends AbstractLifeCycle implements Container, Destroyable, Dumpable.DumpableContainer
 {
     private static final Logger LOG = LoggerFactory.getLogger(ContainerLifeCycle.class);
     private final List<Bean> _beans = new CopyOnWriteArrayList<>();

jetty-util/src/main/java/org/eclipse/jetty/util/component/Dumpable.java

@@ -189,6 +189,10 @@ public interface Dumpable
         for (Iterator<Object> i = container.getBeans().iterator(); i.hasNext(); )
         {
             Object bean = i.next();
+
+            if (container instanceof DumpableContainer && !((DumpableContainer)container).isDumpable(bean))
+                continue; //won't be dumped as a child bean
+
             String nextIndent = indent + ((i.hasNext() || !last) ? "|  " : "   ");
             if (bean instanceof LifeCycle)
             {
@@ -267,4 +271,19 @@ public interface Dumpable
             Dumpable.dumpObjects(out, indent, object);
         };
     }
+
+    /**
+     * DumpableContainer
+     *
+     * A Dumpable that is a container of beans can implement this
+     * interface to allow it to refine which of its beans can be
+     * dumped.
+     */
+    public interface DumpableContainer extends Dumpable
+    {
+        default boolean isDumpable(Object o)
+        {
+            return true;
+        }
+    }
 }