Fixes #22098: metadata-complete attribute handling in deployment (#22099)

* Write the metadata-complete with its true value for the application client. With the current set of the changes, the @ManagedMBean annotation will be processed regardless of the metadata-complete attribute value. This will allow the application client container to process the right set of the annotations.
* Update the dev test to use the new API to get annotation processor.
* When web.xml specifies metadata-complete=true, the web fragments inside this war should have metadata-complete set to true also to allow annotation processing happen as expected.
* Update logic to handle EJB in war case: when extension deployment descriptor is not present in the archive, set the metadata-complete attribute of the extension descriptor using the main descriptor so the annotation processing can happen as expected. Clean up on the javadoc comments also.
* Fix FindBug issue.

Author: honghzzhang

appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/BundleDescriptor.java

@@ -1020,18 +1020,14 @@ public boolean isFullAttribute() {
 
     /**
      * @ return true for following cases:
-     *   1. When the full attribute is true. This attribute only applies to
-     *      ejb module with schema version equal or later than 3.0;
-            web module and schema version equal or later than than 2.5;
-            appclient module and schema version equal or later than 5.0.
-     *   2. When it's been tagged as "full" when processing annotations.
-     *   3. When DD has a version which doesn't allowed annotations.
+     *   1. When it's been tagged as "full" when processing annotations.
+     *   2. When DD has a version which doesn't allowed annotations.
      *   return false otherwise.
      */
     public boolean isFullFlag() {
-        // if the full attribute is true or it's been tagged as full,
+        // if it's been tagged as full,
         // return true
-        if (fullAttribute == true || fullFlag == true) {
+        if (fullFlag == true) {
             return true;
         }
         return isDDWithNoAnnotationAllowed();

appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/annotation/factory/SJSASFactory.java

@@ -76,19 +76,33 @@ public class SJSASFactory extends Factory {
     private ServiceLocator locator;
 
     private Set<String> annotationClassNames = new HashSet<String>();
+    private Set<String> annotationClassNamesMetaDataComplete = new HashSet<String>();
 
+    // we have two system processors to process annotations:
+    // one to process all JavaEE annotations when metadata-complete is false,
+    // another to process a subset of JavaEE annotations when 
+    // metadata-complete is true
     private AnnotationProcessorImpl systemProcessor=null;
+    private AnnotationProcessorImpl systemProcessorMetaDataComplete=null;
 
-    public AnnotationProcessor getAnnotationProcessor() {
+    public AnnotationProcessor getAnnotationProcessor(boolean isMetaDataComplete) {
         AnnotationProcessorImpl processor =
             Factory.getDefaultAnnotationProcessor();
-        processor.setDelegate(systemProcessor);
+        if (!isMetaDataComplete) { 
+            processor.setDelegate(systemProcessor);
+        } else {
+            processor.setDelegate(systemProcessorMetaDataComplete);
+        }
         return processor;
     }
 
     @SuppressWarnings("unchecked")
-    public Set<String> getAnnotations() {
-        return (HashSet<String>)((HashSet<String>)annotationClassNames).clone();
+    public Set<String> getAnnotations(boolean isMetaDataComplete) {
+        if (!isMetaDataComplete) {
+            return (HashSet<String>)((HashSet<String>)annotationClassNames).clone();
+        } else {
+            return (HashSet<String>)((HashSet<String>)annotationClassNamesMetaDataComplete).clone();
+        }
     }
 
     private static String getAnnotationHandlerForStringValue(ActiveDescriptor<AnnotationHandler> onMe) {
@@ -102,24 +116,36 @@ private static String getAnnotationHandlerForStringValue(ActiveDescriptor<Annota
     @SuppressWarnings({ "unused", "unchecked" })
     @PostConstruct
     private void postConstruct() {
-        if (systemProcessor != null) return;
+        if (systemProcessor != null && 
+            systemProcessorMetaDataComplete != null) return;
 
         // initialize our system annotation processor...            
         systemProcessor = new AnnotationProcessorImpl();
+        systemProcessorMetaDataComplete = new AnnotationProcessorImpl();
         for (ActiveDescriptor<?> i : locator.getDescriptors(BuilderHelper.createContractFilter(
                 AnnotationHandler.class.getName()))) {
             ActiveDescriptor<AnnotationHandler> descriptor = (ActiveDescriptor<AnnotationHandler>) i;
 
             String annotationTypeName = getAnnotationHandlerForStringValue(descriptor);
             if (annotationTypeName == null) continue;
-                
+          
             systemProcessor.pushAnnotationHandler(annotationTypeName, new LazyAnnotationHandler(descriptor)); 
             annotationClassNames.add("L" +
+                    annotationTypeName.
+                    replace('.', '/') + ";");  
+
+            // In the current set of the annotations processed by the 
+            // deployment layer, the only annotation that should be
+            // processed even when metadata-complete atribute value is true
+            // is javax.annotation.ManagedBean. If there are more annotations
+            // falling in this category in the future, add them to this list
+            if (annotationTypeName.equals("javax.annotation.ManagedBean")) {
+                systemProcessorMetaDataComplete.pushAnnotationHandler(annotationTypeName, new LazyAnnotationHandler(descriptor));
+                annotationClassNamesMetaDataComplete.add("L" +
                     annotationTypeName.
                     replace('.', '/') + ";");
+            }
         }
-        
-        
     }
 
     private class LazyAnnotationHandler implements AnnotationHandler {

appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/annotation/impl/AppClientScanner.java

@@ -80,7 +80,7 @@ public void process(ReadableArchive archive, ApplicationClientDescriptor bundleD
         setParser(parser);
         doProcess(archive, bundleDesc, classLoader);
         completeProcess(bundleDesc, archive);
-        calculateResults();
+        calculateResults(bundleDesc);
     }
 
     public void process(File archiveFile, ApplicationClientDescriptor bundleDesc, ClassLoader classLoader) throws IOException {

appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/annotation/impl/ModuleScanner.java

@@ -132,7 +132,7 @@ public void process(ReadableArchive archiveFile,
         setParser(parser);
         process(file, bundleDesc, classLoader);
         completeProcess(bundleDesc, archiveFile);
-        calculateResults();
+        calculateResults(bundleDesc);
     }
 
     /**
@@ -150,7 +150,7 @@ protected void completeProcess(T bundleDescr, ReadableArchive archive) throws IO
         addLibraryJars(bundleDescr, archive);
     }
 
-    protected void calculateResults() {
+    protected void calculateResults(T bundleDesc) {
         try {
             classParser.awaitTermination();
         } catch (InterruptedException e) {
@@ -162,7 +162,12 @@ protected void calculateResults() {
         Level logLevel = (System.getProperty("glassfish.deployment.dump.scanning")!=null?Level.INFO:Level.FINE);
         boolean shouldLog = deplLogger.isLoggable(logLevel);
         ParsingContext context = classParser.getContext();
-        for (String annotation: defaultScanner.getAnnotations()) {
+        boolean isFullAttribute = false;
+        if (bundleDesc instanceof BundleDescriptor) {
+            isFullAttribute = ((BundleDescriptor)bundleDesc).isFullAttribute();
+        }
+        Set<String> annotationsToProcess = defaultScanner.getAnnotations(isFullAttribute);
+        for (String annotation: annotationsToProcess) {
             Type type = context.getTypes().getBy(annotation);
 
             // we never found anyone using that type

appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/annotation/introspection/DefaultAnnotationScanner.java

@@ -65,6 +65,7 @@ public class DefaultAnnotationScanner implements AnnotationScanner,
     SJSASFactory factory;
 
     private Set<String> annotations=null;
+    private Set<String> annotationsMetaDataComplete=null;
 
     /**
      * Test if the passed constant pool string is a reference to 
@@ -78,11 +79,20 @@ public boolean isAnnotation(String value) {
     }
 
     public void postConstruct() {
-        annotations = factory.getAnnotations();
+        annotations = factory.getAnnotations(false);
+        annotationsMetaDataComplete = factory.getAnnotations(true);
+    }
+
+    public Set<String> getAnnotations(boolean isMetaDataComplete) {
+        if (!isMetaDataComplete) {
+            return AbstractAnnotationScanner.constantPoolToFQCN(annotations);
+        } else {
+            return AbstractAnnotationScanner.constantPoolToFQCN(annotationsMetaDataComplete);
+        }
     }
 
     @Override
     public Set<String> getAnnotations() {
-        return AbstractAnnotationScanner.constantPoolToFQCN(annotations);
+        return getAnnotations(false);
     }
 }

appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/archivist/Archivist.java

@@ -474,6 +474,14 @@ protected void readAnnotations(ReadableArchive archive, T descriptor,
                             RootDeploymentDescriptor o = extension.getKey().getDefaultDescriptor();
                             if( o != null ) {
                                 o.setModuleDescriptor(descriptor.getModuleDescriptor());
+                                // for the case of extension descriptor not 
+                                // present, set the metadata-complete attribute 
+                                // value of the extension descriptor using the 
+                                // metadata-complete value of main descriptor
+                                if (o instanceof BundleDescriptor) {
+                                    boolean isFullMain = descriptor.isFullAttribute();
+                                    ((BundleDescriptor)o).setFullAttribute(String.valueOf(isFullMain));
+                                }
                             }
                             processAnnotations(o, extension.getKey().getScanner(), archive);
                             if (o!=null && !o.isEmpty()) {
@@ -600,7 +608,12 @@ protected ProcessingResult processAnnotations(RootDeploymentDescriptor bundleDes
                                 "{0} in archive {1} is of version {2}, which cannot support annotations in an application.  Please upgrade the deployment descriptor to be a version supported by Java EE 5.0 (or later).",
                                 new Object[]{ddName, archiveName, bundleDesc.getSpecVersion()}));
             }
-            AnnotationProcessor ap = annotationFactory.getAnnotationProcessor();
+            boolean isFullAttribute = false;
+            if (bundleDesc instanceof BundleDescriptor) {
+                isFullAttribute = ((BundleDescriptor)bundleDesc).isFullAttribute();
+            }
+
+            AnnotationProcessor ap = annotationFactory.getAnnotationProcessor(isFullAttribute);
             ProcessingContext ctx = ap.createContext();
             ctx.setArchive(archive);
             if (annotationErrorHandler != null) {
@@ -1677,19 +1690,15 @@ public Object readMetaInfo(ReadableArchive archive) {
     }
 
     protected boolean isProcessAnnotation(BundleDescriptor descriptor) {
-        // if the system property is set to process annotation for pre-JavaEE5
-        // DD, the semantics of isFull flag is: full attribute is set to 
-        // true in DD. Otherwise the semantics is full attribute set to 
-        // true or it is pre-JavaEE5 DD.
+        // if the system property is set to not process annotation for 
+        // pre-JavaEE5 DD, check whether the current DD is a pre-JavaEE5 DD.
         boolean isFull = false;
-        if (processAnnotationForOldDD) {
-            isFull = descriptor.isFullAttribute();
-        } else {
+        if (!processAnnotationForOldDD) {
             isFull = descriptor.isFullFlag();
         }
 
         // only process annotation when these two requirements satisfied:
-        // 1. It is not a full deployment descriptor
+        // 1. This version of DD should be processed for annotation
         // 2. It is called through dynamic deployment
         return (!isFull && annotationProcessingRequested && classLoader != null);
     }

appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/node/AbstractBundleNode.java

@@ -217,11 +217,7 @@ protected void addBundleNodeAttributes(Element bundleNode, RootDeploymentDescrip
             BundleDescriptor bundleDesc = (BundleDescriptor)descriptor;
             // In the common case that metadata-complete isn't already set to 
             // true, set it to true.
-            // The exception is if the module contains managed beans, which 
-            // can only be processed as annotations in the appclient client 
-            // container runtime.
-            if (! bundleDesc.isDDWithNoAnnotationAllowed() && 
-                ! (bundleDesc.getManagedBeans().size() > 0) ) {
+            if (! bundleDesc.isDDWithNoAnnotationAllowed()) {
                 bundleNode.setAttribute(TagNames.METADATA_COMPLETE, "true"); 
             }
         }

appserver/tests/appserv-tests/devtests/deployment/util/devtests/deployment/util/StandaloneProcessor.java

@@ -205,7 +205,7 @@ public int run(String[] args) throws Exception {
 
                     }
 
-                    AnnotationProcessor ap = serviceLocator.<SJSASFactory>getService(SJSASFactory.class).getAnnotationProcessor();
+                    AnnotationProcessor ap = serviceLocator.<SJSASFactory>getService(SJSASFactory.class).getAnnotationProcessor(false);
 
 
                     // if the user indicated a directory for handlers, time to add the                    

appserver/web/web-glue/src/main/java/org/glassfish/web/deployment/annotation/impl/WarScanner.java

@@ -117,7 +117,7 @@ public void process(ReadableArchive readableArchive, WebBundleDescriptor webBund
 
         if (isScanOtherLibraries()) {
             addLibraryJars(webBundleDesc, readableArchive);
-            calculateResults();
+            calculateResults(webBundleDesc);
             return;
         }
 
@@ -144,7 +144,7 @@ public void process(ReadableArchive readableArchive, WebBundleDescriptor webBund
             }
             scanXmlDefinedClassesIfNecessary(webBundleDesc);
         }
-        calculateResults();
+        calculateResults(webBundleDesc);
     }
 
     // This is not mandated by the spec. It is for WSIT.

appserver/web/web-glue/src/main/java/org/glassfish/web/deployment/archivist/WebArchivist.java

@@ -330,6 +330,13 @@ protected void postAnnotationProcess(WebBundleDescriptorImpl descriptor,
             Map<ExtensionsArchivist, RootDeploymentDescriptor> localExtensions =
                     new HashMap<ExtensionsArchivist, RootDeploymentDescriptor>();
             for (WebFragmentDescriptor wfDesc : wfList) {
+                // if web.xml specifies metadata-complete=true,
+                // all web fragment metadata-complete
+                // should be overridden and be true also
+                if (descriptor.isFullAttribute()) {
+                  wfDesc.setFullAttribute(
+                      String.valueOf(descriptor.isFullAttribute()));
+                }
                 super.readAnnotations(archive, wfDesc, localExtensions);
             }