Delete LegacyInstancesAreScopedToHudson and associated machinery (#11225)

jglick · web-flow · commit 30f301b517d8 · 2025-11-14T20:03:13.000-07:00
* Deleting `LegacyInstancesAreScopedToHudson` and associated machinery * In fact we can deprecate external use of the `ExtensionList.<init>(Jenkins, Class, CopyOnWriteArrayList)` constructor #11225 (comment) * Adjusting Javadoc to guide developers to simpler APIs like `ExtensionList.lookup`
diff --git a/core/src/main/java/hudson/DescriptorExtensionList.java b/core/src/main/java/hudson/DescriptorExtensionList.java
@@ -34,16 +34,10 @@
 import hudson.model.ViewDescriptor;
 import hudson.slaves.NodeDescriptor;
 import hudson.tasks.Publisher;
-import hudson.util.AdaptedIterator;
-import hudson.util.Iterators.FlattenIterator;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import jenkins.ExtensionComponentSet;
@@ -106,7 +100,7 @@ protected DescriptorExtensionList(Hudson hudson, Class<T> describableType) {
     }
 
     protected DescriptorExtensionList(Jenkins jenkins, Class<T> describableType) {
-        super(jenkins, (Class) Descriptor.class, (CopyOnWriteArrayList) getLegacyDescriptors(describableType));
+        super(jenkins, (Class) Descriptor.class);
         this.describableType = describableType;
     }
 
@@ -238,46 +232,19 @@ private ExtensionList<Descriptor> getDescriptorExtensionList() {
     }
 
     /**
-     * Stores manually registered Descriptor instances. Keyed by the {@link Describable} type.
-     */
-    @SuppressWarnings("rawtypes")
-    private static final Map<Class, CopyOnWriteArrayList<ExtensionComponent<Descriptor>>> legacyDescriptors = new ConcurrentHashMap<>();
-
-    @SuppressWarnings({"unchecked", "rawtypes"})
-    private static <T extends Describable<T>> CopyOnWriteArrayList<ExtensionComponent<Descriptor>> getLegacyDescriptors(Class<T> type) {
-        return legacyDescriptors.computeIfAbsent(type, key -> new CopyOnWriteArrayList());
-    }
-
-    /**
-     * List up all the legacy instances currently in use.
+     * @deprecated Now always empty.
      */
+    @Deprecated
     public static Iterable<Descriptor> listLegacyInstances() {
-        return new Iterable<>() {
-            @Override
-            public Iterator<Descriptor> iterator() {
-                return new AdaptedIterator<ExtensionComponent<Descriptor>, Descriptor>(
-                    new FlattenIterator<ExtensionComponent<Descriptor>, CopyOnWriteArrayList<ExtensionComponent<Descriptor>>>(legacyDescriptors.values()) {
-                        @Override
-                        protected Iterator<ExtensionComponent<Descriptor>> expand(CopyOnWriteArrayList<ExtensionComponent<Descriptor>> v) {
-                            return v.iterator();
-                        }
-                    }) {
-
-                    @Override
-                    protected Descriptor adapt(ExtensionComponent<Descriptor> item) {
-                        return item.getInstance();
-                    }
-                };
-            }
-        };
+        return List.of();
     }
 
     /**
-     * Exposed just for the test harness. Clear legacy instances.
+     * @deprecated No longer does anything.
      */
-    @SuppressFBWarnings(value = "HSM_HIDING_METHOD", justification = "TODO needs triage")
+    @SuppressFBWarnings(value = "HSM_HIDING_METHOD", justification = "irrelevant now")
+    @Deprecated
     public static void clearLegacyInstances() {
-        legacyDescriptors.clear();
     }
 
     private static final Logger LOGGER = Logger.getLogger(DescriptorExtensionList.class.getName());
diff --git a/core/src/main/java/hudson/ExtensionList.java b/core/src/main/java/hudson/ExtensionList.java
@@ -26,11 +26,9 @@
 
 import edu.umd.cs.findbugs.annotations.CheckForNull;
 import edu.umd.cs.findbugs.annotations.NonNull;
-import hudson.ExtensionPoint.LegacyInstancesAreScopedToHudson;
 import hudson.init.InitMilestone;
 import hudson.model.Hudson;
 import hudson.util.AdaptedIterator;
-import hudson.util.DescriptorList;
 import hudson.util.Iterators;
 import java.util.AbstractList;
 import java.util.ArrayList;
@@ -39,11 +37,8 @@
 import java.util.IdentityHashMap;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
-import java.util.Vector;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -57,22 +52,14 @@
  * Retains the known extension instances for the given type 'T'.
  *
  * <p>
- * Extensions are loaded lazily on demand and automatically by using {@link ExtensionFinder}, but this
- * class also provides a mechanism to provide compatibility with the older {@link DescriptorList}-based
- * manual registration,
- *
- * <p>
- * All {@link ExtensionList} instances should be owned by {@link jenkins.model.Jenkins}, even though
- * extension points can be defined by anyone on any type. Use {@link jenkins.model.Jenkins#getExtensionList(Class)}
- * and {@link jenkins.model.Jenkins#getDescriptorList(Class)} to obtain the instances.
+ * Use {@link Extension} to register extensions.
+ * Use {@link #lookup}, {@link #lookupSingleton}, or {@link #lookupFirst} to find them.
  *
  * @param <T>
  *      Type of the extension point. This class holds instances of the subtypes of 'T'.
  *
  * @author Kohsuke Kawaguchi
  * @since 1.286
- * @see jenkins.model.Jenkins#getExtensionList(Class)
- * @see jenkins.model.Jenkins#getDescriptorList(Class)
  */
 public class ExtensionList<T> extends AbstractList<T> implements OnMaster {
     /**
@@ -93,7 +80,7 @@ public class ExtensionList<T> extends AbstractList<T> implements OnMaster {
     private final List<ExtensionListListener> listeners = new CopyOnWriteArrayList<>();
 
     /**
-     * Place to store manually registered instances with the per-Hudson scope.
+     * Place to store manually registered instances.
      * {@link CopyOnWriteArrayList} is used here to support concurrent iterations and mutation.
      */
     private final CopyOnWriteArrayList<ExtensionComponent<T>> legacyInstances;
@@ -113,20 +100,17 @@ protected ExtensionList(Jenkins jenkins, Class<T> extensionType) {
 
     /**
      * @deprecated as of 1.416
-     *      Use {@link #ExtensionList(Jenkins, Class, CopyOnWriteArrayList)}
+     *      Use {@link #ExtensionList(Jenkins, Class)}
      */
     @Deprecated
     protected ExtensionList(Hudson hudson, Class<T> extensionType, CopyOnWriteArrayList<ExtensionComponent<T>> legacyStore) {
         this((Jenkins) hudson, extensionType, legacyStore);
     }
 
     /**
-     *
-     * @param legacyStore
-     *      Place to store manually registered instances. The version of the constructor that
-     *      omits this uses a new {@link Vector}, making the storage lifespan tied to the life of  {@link ExtensionList}.
-     *      If the manually registered instances are scoped to VM level, the caller should pass in a static list.
+     * @deprecated {@link #ExtensionList(Jenkins, Class)} should suffice
      */
+    @Deprecated
     protected ExtensionList(Jenkins jenkins, Class<T> extensionType, CopyOnWriteArrayList<ExtensionComponent<T>> legacyStore) {
         this.hudson = (Hudson) jenkins;
         this.jenkins = jenkins;
@@ -437,11 +421,7 @@ public static <T> ExtensionList<T> create(Hudson hudson, Class<T> type) {
 
     @SuppressWarnings({"unchecked", "rawtypes"})
     public static <T> ExtensionList<T> create(Jenkins jenkins, Class<T> type) {
-        if (type.getAnnotation(LegacyInstancesAreScopedToHudson.class) != null)
-            return new ExtensionList<>(jenkins, type);
-        else {
-            return new ExtensionList(jenkins, type, staticLegacyInstances.computeIfAbsent(type, key -> new CopyOnWriteArrayList()));
-        }
+        return new ExtensionList<>(jenkins, type);
     }
 
     /**
@@ -506,16 +486,10 @@ public static <T> ExtensionList<T> create(Jenkins jenkins, Class<T> type) {
     }
 
     /**
-     * Places to store static-scope legacy instances.
-     */
-    @SuppressWarnings("rawtypes")
-    private static final Map<Class, CopyOnWriteArrayList> staticLegacyInstances = new ConcurrentHashMap<>();
-
-    /**
-     * Exposed for the test harness to clear all legacy extension instances.
+     * @deprecated No longer does anything.
      */
+    @Deprecated
     public static void clearLegacyInstances() {
-        staticLegacyInstances.clear();
     }
 
     private static final Logger LOGGER = Logger.getLogger(ExtensionList.class.getName());
diff --git a/core/src/main/java/hudson/ExtensionPoint.java b/core/src/main/java/hudson/ExtensionPoint.java
@@ -29,7 +29,6 @@
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
-import jenkins.model.Jenkins;
 
 /**
  * Marker interface that designates extensible components
@@ -47,10 +46,9 @@
  */
 public interface ExtensionPoint {
     /**
-     * Used by designers of extension points (direct subtypes of {@link ExtensionPoint}) to indicate that
-     * the legacy instances are scoped to {@link Jenkins} instance. By default, legacy instances are
-     * static scope.
+     * @deprecated No longer has any effect.
      */
+    @Deprecated
     @Target(TYPE)
     @Retention(RUNTIME)
     @interface LegacyInstancesAreScopedToHudson {}
diff --git a/core/src/main/java/hudson/cli/CLICommand.java b/core/src/main/java/hudson/cli/CLICommand.java
@@ -31,7 +31,6 @@
 import hudson.Extension;
 import hudson.ExtensionList;
 import hudson.ExtensionPoint;
-import hudson.ExtensionPoint.LegacyInstancesAreScopedToHudson;
 import hudson.Functions;
 import hudson.cli.declarative.CLIMethod;
 import hudson.cli.declarative.OptionHandlerExtension;
@@ -103,7 +102,6 @@
  * @since 1.302
  * @see CLIMethod
  */
-@LegacyInstancesAreScopedToHudson
 public abstract class CLICommand implements ExtensionPoint, Cloneable {
 
     /**
diff --git a/core/src/main/java/hudson/model/AdministrativeMonitor.java b/core/src/main/java/hudson/model/AdministrativeMonitor.java
@@ -27,7 +27,6 @@
 import hudson.Extension;
 import hudson.ExtensionList;
 import hudson.ExtensionPoint;
-import hudson.ExtensionPoint.LegacyInstancesAreScopedToHudson;
 import hudson.security.Permission;
 import hudson.triggers.SCMTrigger;
 import hudson.triggers.TimerTrigger;
@@ -88,7 +87,6 @@
  * @since 1.273
  * @see Jenkins#administrativeMonitors
  */
-@LegacyInstancesAreScopedToHudson
 public abstract class AdministrativeMonitor extends AbstractModelObject implements ExtensionPoint, StaplerProxy {
     /**
      * Human-readable ID of this monitor, which needs to be unique within the system.
diff --git a/core/src/main/java/jenkins/model/Jenkins.java b/core/src/main/java/jenkins/model/Jenkins.java
@@ -58,7 +58,6 @@
 import hudson.ExtensionComponent;
 import hudson.ExtensionFinder;
 import hudson.ExtensionList;
-import hudson.ExtensionPoint;
 import hudson.FilePath;
 import hudson.Functions;
 import hudson.Launcher;
@@ -197,7 +196,6 @@
 import hudson.util.Futures;
 import hudson.util.HudsonIsLoading;
 import hudson.util.HudsonIsRestarting;
-import hudson.util.Iterators;
 import hudson.util.JenkinsReloadFailed;
 import hudson.util.LogTaskListener;
 import hudson.util.MultipartFormDataParser;
@@ -1507,8 +1505,7 @@ public CloudSet getCloud() {
      */
     @SuppressWarnings("rawtypes") // too late to fix
     public Descriptor getDescriptor(String id) {
-        // legacy descriptors that are registered manually doesn't show up in getExtensionList, so check them explicitly.
-        Iterable<Descriptor> descriptors = Iterators.sequence(getExtensionList(Descriptor.class), DescriptorExtensionList.listLegacyInstances());
+        Iterable<Descriptor> descriptors = getExtensionList(Descriptor.class);
         for (Descriptor d : descriptors) {
             if (d.getId().equals(id)) {
                 return d;
@@ -2817,14 +2814,7 @@ public Lifecycle getLifecycle() {
     }
 
     /**
-     * Returns {@link ExtensionList} that retains the discovered instances for the given extension type.
-     *
-     * @param extensionType
-     *      The base type that represents the extension point. Normally {@link ExtensionPoint} subtype
-     *      but that's not a hard requirement.
-     * @return
-     *      Can be an empty list but never null.
-     * @see ExtensionList#lookup
+     * An obsolete alias for {@link ExtensionList#lookup}.
      */
     @SuppressWarnings("unchecked")
     public <T> ExtensionList<T> getExtensionList(Class<T> extensionType) {
@@ -2848,7 +2838,7 @@ public ExtensionList getExtensionList(String extensionType) throws ClassNotFound
     /**
      * Returns {@link ExtensionList} that retains the discovered {@link Descriptor} instances for the given
      * kind of {@link Describable}.
-     *
+     * <p>Assuming an appropriate {@link Descriptor} subtype, for most purposes you can simply use {@link ExtensionList#lookup}.
      * @return
      *      Can be an empty list but never null.
      */
