add jakartaee8 platform for versionless

dev/com.ibm.websphere.appserver.features/visibility/private/com.ibm.websphere.appserver.eeCompatible-8.0.feature

@@ -8,4 +8,4 @@ Subsystem-Version: 8.0.0
 kind=ga
 edition=core
 WLP-Activation-Type: parallel
-WLP-Platform: javaee-8.0
+WLP-Platform: javaee-8.0,jakartaee-8.0

dev/com.ibm.ws.kernel.feature.core/src/com/ibm/ws/kernel/feature/internal/FeatureResolverImpl.java

@@ -257,9 +257,7 @@ private Collection<String> collectConfiguredPlatforms(Repository repo, Collectio
 
         for (String plat : rootPlatforms) {
             //needs check for duplicate platforms with different versions, ex. can't have javaee7.0 and javaee8.0
-            plat = plat.trim();
-
-            ProvisioningFeatureDefinition platformFeature = allCompatibilityFeatures.get(plat.toLowerCase());
+            ProvisioningFeatureDefinition platformFeature = allCompatibilityFeatures.get(plat);
 
             if (platformFeature == null) {
                 selectionContext.getResult().addMissingPlatform(plat);
@@ -416,6 +414,19 @@ private boolean featureListContainsFeatureBaseName(Collection<String> featureLis
         return false;
     }
 
+    /**
+     * Trim and lowercase the platform list
+     * @param rootPlatforms
+     * @return
+     */
+    private List<String> normalizeRootPlatforms(Collection<String> rootPlatforms){
+        List<String> normalizedPlatforms = new ArrayList<String>();
+        for(String plat : rootPlatforms){
+            normalizedPlatforms.add(plat.trim().toLowerCase());
+        }
+        return normalizedPlatforms;
+    }
+
     //////// BEGIN - deprecated resolveFeatures() methods without platforms
 
     @SuppressWarnings("deprecation")
@@ -571,15 +582,17 @@ public Result doResolve(Repository repository,
                             Collection<String> rootPlatforms) {
 
         SelectionContext selectionContext = new SelectionContext(repository, allowedMultipleVersions, supportedProcessTypes);
+        Collection<String> rootPlatformFeatures = new ArrayList<String>();
 
         if (hasRootVersionlessFeatures(repository, rootFeatures)) {
             selectionContext.setHasVersionlessFeatures();
             processCompatibilityFeatures(repository.getFeatures());
 
-            rootPlatforms = collectConfiguredPlatforms(repository, rootPlatforms, selectionContext);
-            rootPlatforms.addAll(collectEnvironmentPlatforms(repository, rootPlatforms, selectionContext));
-            rootPlatforms.addAll(collectFeaturePlatforms(repository, rootPlatforms, rootFeatures, selectionContext));
-            for (String platform : rootPlatforms) {
+            rootPlatforms = normalizeRootPlatforms(rootPlatforms);
+            rootPlatformFeatures = collectConfiguredPlatforms(repository, rootPlatforms, selectionContext);
+            rootPlatformFeatures.addAll(collectEnvironmentPlatforms(repository, rootPlatformFeatures, selectionContext));
+            rootPlatformFeatures.addAll(collectFeaturePlatforms(repository, rootPlatformFeatures, rootFeatures, selectionContext));
+            for (String platform : rootPlatformFeatures) {
                 selectionContext.getResult().addResolvedPlatform(repository.getFeature(platform).getPlatformName());
             }
         }
@@ -595,8 +608,8 @@ public Result doResolve(Repository repository,
         // This will ensure that the root and pre-resolved features do not conflict
         Collection<String> rootFeaturesList = new ArrayList<String>(rootFeatures);
         //Implementation for platform element
-        if (rootPlatforms != null && selectionContext.getHasVersionlessFeatures()) {
-            rootFeaturesList.addAll(rootPlatforms);
+        if (rootPlatformFeatures != null && selectionContext.getHasVersionlessFeatures()) {
+            rootFeaturesList.addAll(rootPlatformFeatures);
         }
 
         //add versionless after normal resolution for packaging
@@ -606,7 +619,7 @@ public Result doResolve(Repository repository,
         }
         //preresolve versionless features for regular resolution
         else if (selectionContext.getHasVersionlessFeatures()) {
-            preresolveVersionless(rootFeaturesList, selectionContext, rootPlatforms, filteredVersionless);
+            preresolveVersionless(rootFeaturesList, selectionContext, rootPlatformFeatures, filteredVersionless);
         }
 
         selectionContext.primeSelected(preResolved);
@@ -639,7 +652,7 @@ else if (selectionContext.getHasVersionlessFeatures()) {
         if (!filteredVersionless.isEmpty() && allowedMultipleVersions != null) {
             addBackVersionless(filteredVersionless, selectionContext);
         } else if (selectionContext.getHasVersionlessFeatures()) {
-            finalizeVersionlessResults(selectionContext, filteredVersionless);
+            finalizeVersionlessResults(selectionContext, filteredVersionless, rootPlatforms);
         }
 
         // Finally return the selected result
@@ -964,7 +977,7 @@ private boolean shouldAddCompatibleFeature(FeatureResolverResultImpl result, Str
      * @param selectionContext
      * @param filteredVersionless
      */
-    private void finalizeVersionlessResults(SelectionContext selectionContext, List<String> filteredVersionless) {
+    private void finalizeVersionlessResults(SelectionContext selectionContext, List<String> filteredVersionless, Collection<String> rootPlatforms) {
         FeatureResolverResultImpl result = selectionContext.getResult();
         result._resolved.addAll(filteredVersionless);
 
@@ -976,8 +989,18 @@ private void finalizeVersionlessResults(SelectionContext selectionContext, List<
         for (String feature : result.getResolvedFeatures()) {
             ProvisioningFeatureDefinition featureDef = selectionContext.getRepository().getFeature(feature);
             if (featureDef.isCompatibility()) {
-                if (existingPlatforms.contains(featureDef.getPlatformName())) {
-                    result.addResolvedPlatform(featureDef.getPlatformName());
+                boolean addedPlatform = false;
+                if(!rootPlatforms.isEmpty()){
+                    for(String platName : featureDef.getPlatformNames()){
+                        if(rootPlatforms.contains(platName)){
+                            result.addResolvedPlatform(platName);
+                            addedPlatform = true;
+                        }
+                    }
+                }
+                if (existingPlatforms.contains(featureDef.getPlatformName()) && !addedPlatform) {
+                    String platforms = featureDef.getPlatformName();
+                    result.addResolvedPlatform(platforms);
                 }
             }
         }
@@ -1037,7 +1060,9 @@ private void processCompatibilityFeatures(List<ProvisioningFeatureDefinition> fe
         allCompatibilityFeatures = new HashMap<>();
         for (ProvisioningFeatureDefinition feature : features) {
             if (feature.isCompatibility()) {
-                allCompatibilityFeatures.put(feature.getPlatformName().toLowerCase(), feature);
+                for(String platformName : feature.getPlatformNames()){
+                    allCompatibilityFeatures.put(platformName.toLowerCase(), feature);
+                }
             }
         }
     }

dev/com.ibm.ws.kernel.feature.core/src/com/ibm/ws/kernel/feature/internal/subsystem/FeatureRepository.java

@@ -986,7 +986,9 @@ private void updateMaps(SubsystemFeatureDefinitionImpl def) {
             publicFeatureNameToSymbolicName.put(lowerFeature(attr.symbolicName), attr.symbolicName);
         } else if (def.getVisibility() == Visibility.PRIVATE) {
             if ((attr.platforms != null) && !attr.platforms.isEmpty()) {
-                putCompatibilityFeature(def.getPlatformName(), def);
+                for(String plat : def.getPlatformNames()){
+                    putCompatibilityFeature(plat, def);
+                }
             }
         }
 

dev/com.ibm.ws.kernel.feature.resolver_fat/fat/src/com/ibm/ws/feature/tests/VersionlessMessagesTest.java

@@ -105,6 +105,16 @@ public void versionless_NoFeatureVersionExistsForPlatform() throws Exception {
         startServer_CheckLogs("CWWKF0054E:");
     }
 
+    @Test // 54E
+    public void versionless_NoFeatureVersionExistsForPlatformJakartaee8() throws Exception {
+
+        initTest(SERVER_NAME_NO_VERSION_OF_FEATURE_EXISTS_FOR_PLATFORM, "jakartaee-8.0", "data", null);
+
+        // Expect message: "CWWKF0054E: The {0} versionless feature does not have a version that belongs to the {1} platform.
+        allowedMessages = new String[] { "CWWKF0050E", "CWWKF0055E", "CWWKF0054E" };
+        startServer_CheckLogs("CWWKF0054E:");
+    }
+
     @Test // 55E
     public void versionless_NoConfiguredPlatform() throws Exception {
 

dev/com.ibm.ws.kernel.feature.resolver_fat/fat/src/com/ibm/ws/feature/tests/VersionlessServletToMicroProfileTest.java

@@ -36,6 +36,8 @@ public class VersionlessServletToMicroProfileTest extends VersionlessTest {
     public static final String SERVER_NAME_SERVLET6_HEALTH = "Servlet6toHealth";
     public static final String SERVER_NAME_SERVLET6_METRICS = "Servlet6toMetrics";
 
+    public static final String SERVER_JAKARTAEE8 = "jakartaee8";
+
     public static final String[] ALLOWED_ERRORS = { "CWWKF0001E", "CWWKF0048E" };
 
     public static final TestCase[] TEST_CASES = {
@@ -91,6 +93,11 @@ public class VersionlessServletToMicroProfileTest extends VersionlessTest {
         new TestCase("servlet6MetricsMin", SERVER_NAME_SERVLET6_METRICS,
                      PlatformConstants.MICROPROFILE_ASCENDING,
                      new String[] { "mpMetrics-5.0" }, TestCase.NO_FAILURES, ALLOWED_ERRORS,
+                     TestCase.JAVA_11),
+
+        //JAKARTA8 TEST
+        new TestCase("jakartaee8", SERVER_JAKARTAEE8, "",
+                     new String[] { "servlet-4.0", "jpa-2.2"}, TestCase.NO_FAILURES, ALLOWED_ERRORS,
                      TestCase.JAVA_11)
     };
 

dev/com.ibm.ws.kernel.feature.resolver_fat/fat/src/com/ibm/ws/feature/tests/VersionlessTest.java

@@ -107,7 +107,9 @@ public void withServer(String serverName, String[] allowedErrors, String preferr
                            String[] expectedResolved,
                            FailableConsumer<LibertyServer, Exception> action) throws Exception {
         LibertyServer server = LibertyServerFactory.getLibertyServer(serverName);
-        server.addEnvVar("PREFERRED_PLATFORM_VERSIONS", preferredVersions);
+        if(!preferredVersions.isEmpty()){
+            server.addEnvVar("PREFERRED_PLATFORM_VERSIONS", preferredVersions);
+        }
 
         server.startServer();
         try {

dev/com.ibm.ws.kernel.feature.resolver_fat/publish/servers/jakartaee8/bootstrap.properties

@@ -0,0 +1,14 @@
+###############################################################################
+# Copyright (c) 2017 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License 2.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-2.0/
+# 
+# SPDX-License-Identifier: EPL-2.0
+#
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+bootstrap.include=../testports.properties
+com.ibm.ws.logging.trace.specification=*=info

dev/com.ibm.ws.kernel.feature.resolver_fat/publish/servers/jakartaee8/server.xml

@@ -0,0 +1,23 @@
+<!--
+    Copyright (c) 2017, 2024 IBM Corporation and others.
+    All rights reserved. This program and the accompanying materials
+    are made available under the terms of the Eclipse Public License 2.0
+    which accompanies this distribution, and is available at
+    http://www.eclipse.org/legal/epl-2.0/
+
+    SPDX-License-Identifier: EPL-2.0
+
+    Contributors:
+        IBM Corporation - initial API and implementation
+ -->
+<server>
+
+    <featureManager>
+        <platform>jakartaee-8.0</platform>
+        <feature>servlet</feature>
+        <feature>jpa</feature>
+    </featureManager>
+
+    <include location="../fatTestCommon.xml"/>
+
+</server>