SmallRye Context Propagation 1.0.16

bom/application/pom.xml

@@ -41,9 +41,9 @@
         <smallrye-open-api.version>2.0.13</smallrye-open-api.version>
         <smallrye-graphql.version>1.0.14</smallrye-graphql.version>
         <smallrye-opentracing.version>1.3.4</smallrye-opentracing.version>
-        <smallrye-fault-tolerance.version>4.3.1</smallrye-fault-tolerance.version>
+        <smallrye-fault-tolerance.version>4.3.2</smallrye-fault-tolerance.version>
         <smallrye-jwt.version>2.3.1</smallrye-jwt.version>
-        <smallrye-context-propagation.version>1.0.13</smallrye-context-propagation.version>
+        <smallrye-context-propagation.version>1.0.19</smallrye-context-propagation.version>
         <smallrye-reactive-streams-operators.version>1.0.13</smallrye-reactive-streams-operators.version>
         <smallrye-converter-api.version>1.2.2</smallrye-converter-api.version>
         <smallrye-reactive-messaging.version>2.4.0</smallrye-reactive-messaging.version>

core/runtime/pom.xml

@@ -119,6 +119,7 @@
                 <configuration>
                     <parentFirstArtifacts>
                         <parentFirstArtifact>io.quarkus:quarkus-bootstrap-runner</parentFirstArtifact>
+                        <parentFirstArtifact>io.smallrye.common:smallrye-common-io</parentFirstArtifact>
                         <parentFirstArtifact>org.wildfly.common:wildfly-common</parentFirstArtifact>
                         <parentFirstArtifact>org.graalvm.sdk:graal-sdk</parentFirstArtifact>
                         <parentFirstArtifact>org.graalvm.nativeimage:svm</parentFirstArtifact>

extensions/arc/deployment/src/test/java/io/quarkus/arc/test/unproxyable/SynthProxiableBeanWithoutNoArgConstructorTest.java

@@ -0,0 +1,85 @@
+package io.quarkus.arc.test.unproxyable;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.function.Consumer;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.inject.Vetoed;
+
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.arc.Arc;
+import io.quarkus.arc.InstanceHandle;
+import io.quarkus.arc.deployment.BeanRegistrarBuildItem;
+import io.quarkus.arc.processor.BeanRegistrar;
+import io.quarkus.builder.BuildChainBuilder;
+import io.quarkus.builder.BuildContext;
+import io.quarkus.builder.BuildStep;
+import io.quarkus.gizmo.MethodDescriptor;
+import io.quarkus.gizmo.ResultHandle;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class SynthProxiableBeanWithoutNoArgConstructorTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+                    .addClasses(SynthBean.class))
+            .addBuildChainCustomizer(buildCustomizer());
+
+    static Consumer<BuildChainBuilder> buildCustomizer() {
+        return new Consumer<BuildChainBuilder>() {
+
+            @Override
+            public void accept(BuildChainBuilder builder) {
+                builder.addBuildStep(new BuildStep() {
+
+                    @Override
+                    public void execute(BuildContext context) {
+                        context.produce(new BeanRegistrarBuildItem(new BeanRegistrar() {
+                            @Override
+                            public void register(RegistrationContext context) {
+                                context.configure(SynthBean.class)
+                                        .scope(ApplicationScoped.class)
+                                        .types(SynthBean.class)
+                                        .unremovable()
+                                        .creator(mc -> {
+                                            ResultHandle ret = mc.newInstance(
+                                                    MethodDescriptor.ofConstructor(SynthBean.class, String.class),
+                                                    mc.load("foo"));
+                                            mc.returnValue(ret);
+                                        })
+                                        .done();
+                            }
+                        }));
+                    }
+                }).produces(BeanRegistrarBuildItem.class).build();
+            }
+        };
+    }
+
+    @Test
+    public void testSyntheticBean() {
+        InstanceHandle<SynthBean> instance = Arc.container().instance(SynthBean.class);
+        assertTrue(instance.isAvailable());
+        assertEquals("foo", instance.get().getString());
+    }
+
+    @Vetoed
+    static class SynthBean {
+        private String s;
+
+        public SynthBean(String s) {
+            this.s = s;
+        }
+
+        public String getString() {
+            return s;
+        }
+    }
+}

extensions/smallrye-context-propagation/deployment/src/main/java/io/quarkus/smallrye/context/deployment/SmallRyeContextPropagationProcessor.java

@@ -23,6 +23,7 @@
 import io.quarkus.deployment.util.ServiceUtil;
 import io.quarkus.smallrye.context.runtime.SmallRyeContextPropagationProvider;
 import io.quarkus.smallrye.context.runtime.SmallRyeContextPropagationRecorder;
+import io.smallrye.context.SmallRyeManagedExecutor;
 
 /**
  * The deployment processor for MP-CP applications
@@ -76,8 +77,9 @@ void build(SmallRyeContextPropagationRecorder recorder,
 
         // Synthetic bean for ManagedExecutor
         syntheticBeans.produce(
-                SyntheticBeanBuildItem.configure(ManagedExecutor.class)
+                SyntheticBeanBuildItem.configure(SmallRyeManagedExecutor.class)
                         .scope(ApplicationScoped.class)
+                        .addType(ManagedExecutor.class)
                         .defaultBean()
                         .unremovable()
                         .supplier(recorder.initializeManagedExecutor(executorBuildItem.getExecutorProxy()))

extensions/smallrye-context-propagation/runtime/src/main/java/io/quarkus/smallrye/context/runtime/SmallRyeContextPropagationProvider.java

@@ -7,15 +7,17 @@
 import org.eclipse.microprofile.context.ThreadContext;
 
 import io.quarkus.arc.DefaultBean;
+import io.smallrye.context.SmallRyeThreadContext;
 
 @Dependent
 public class SmallRyeContextPropagationProvider {
 
     @Produces
     @Singleton
     @DefaultBean
-    public ThreadContext getAllThreadContext() {
-        return ThreadContext.builder().propagated(ThreadContext.ALL_REMAINING).cleared().unchanged().build();
+    public SmallRyeThreadContext getAllThreadContext() {
+        return (SmallRyeThreadContext) ThreadContext.builder().propagated(ThreadContext.ALL_REMAINING).cleared().unchanged()
+                .build();
     }
 
 }

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/Beans.java

@@ -789,6 +789,37 @@ static void validateBean(BeanInfo bean, List<Throwable> errors, List<BeanDeploym
                     }
                 }
             }
+        } else if (bean.isSynthetic()) {
+            // this is for synthetic beans that need to be proxied but their classes don't have no-args constructor
+            ClassInfo beanClass = getClassByName(bean.getDeployment().getBeanArchiveIndex(), bean.getBeanClass());
+            MethodInfo noArgsConstructor = beanClass.method(Methods.INIT);
+            if (bean.getScope().isNormal() && !Modifier.isInterface(beanClass.flags()) && noArgsConstructor == null) {
+                if (bean.getDeployment().transformUnproxyableClasses) {
+                    DotName superName = beanClass.superName();
+                    if (!DotNames.OBJECT.equals(superName)) {
+                        ClassInfo superClass = bean.getDeployment().getBeanArchiveIndex().getClassByName(beanClass.superName());
+                        if (superClass == null || !superClass.hasNoArgsConstructor()) {
+                            // Bean class extends a class without no-args constructor
+                            // It is not possible to generate a no-args constructor reliably
+                            superName = null;
+                        }
+                    }
+                    if (superName != null) {
+                        String superClassName = superName.toString().replace('.', '/');
+                        bytecodeTransformerConsumer.accept(new BytecodeTransformer(beanClass.name().toString(),
+                                new NoArgConstructorTransformFunction(superClassName)));
+                    } else {
+                        errors.add(new DeploymentException(
+                                "It's not possible to add a synthetic constructor with no parameters to the unproxyable bean class: "
+                                        +
+                                        beanClass));
+                    }
+                } else {
+                    errors.add(new DeploymentException(String
+                            .format("Normal scoped beans must declare a non-private constructor with no parameters: %s",
+                                    bean)));
+                }
+            }
         }
     }
 

independent-projects/bootstrap/core/src/main/java/io/quarkus/bootstrap/classloading/JarClassPathElement.java

@@ -8,6 +8,7 @@
 import java.io.InputStream;
 import java.io.InterruptedIOException;
 import java.io.UncheckedIOException;
+import java.lang.reflect.Method;
 import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -18,6 +19,7 @@
 import java.security.cert.Certificate;
 import java.util.Enumeration;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.jar.JarEntry;
@@ -30,7 +32,23 @@
  */
 public class JarClassPathElement implements ClassPathElement {
 
+    private static final int JAVA_VERSION;
+
+    static {
+        int version = 8;
+        try {
+            Method versionMethod = Runtime.class.getMethod("version");
+            Object v = versionMethod.invoke(null);
+            List<Integer> list = (List<Integer>) v.getClass().getMethod("version").invoke(v);
+            version = list.get(0);
+        } catch (Exception e) {
+            //version 8
+        }
+        JAVA_VERSION = version;
+    }
+
     private static final Logger log = Logger.getLogger(JarClassPathElement.class);
+    public static final String META_INF_VERSIONS = "META-INF/versions/";
     private final File file;
     private final URL jarPath;
     private final Path root;
@@ -147,6 +165,26 @@ public Set<String> apply(JarFile jarFile) {
                         paths.add(entry.getName());
                     }
                 }
+                //multi release jars can add additional entries
+                if (JarFiles.isMultiRelease(jarFile)) {
+                    Set<String> copy = new HashSet<>(paths);
+                    for (String i : copy) {
+                        if (i.startsWith(META_INF_VERSIONS)) {
+                            String part = i.substring(META_INF_VERSIONS.length());
+                            int slash = part.indexOf("/");
+                            if (slash != -1) {
+                                try {
+                                    int ver = Integer.parseInt(part.substring(0, slash));
+                                    if (ver <= JAVA_VERSION) {
+                                        paths.add(part.substring(slash + 1));
+                                    }
+                                } catch (NumberFormatException e) {
+                                    log.debug("Failed to parse META-INF/versions entry", e);
+                                }
+                            }
+                        }
+                    }
+                }
                 return paths;
             }
         }));

independent-projects/bootstrap/runner/pom.xml

@@ -19,6 +19,10 @@
     </description>
 
     <dependencies>
+        <dependency>
+            <groupId>io.smallrye.common</groupId>
+            <artifactId>smallrye-common-io</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.graalvm.sdk</groupId>
             <artifactId>graal-sdk</artifactId>

independent-projects/bootstrap/runner/src/main/java/io/quarkus/bootstrap/runner/JarResource.java

@@ -1,5 +1,7 @@
 package io.quarkus.bootstrap.runner;
 
+import io.smallrye.common.io.jar.JarEntries;
+import io.smallrye.common.io.jar.JarFiles;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.MalformedURLException;
@@ -10,6 +12,8 @@
 import java.security.CodeSource;
 import java.security.ProtectionDomain;
 import java.security.cert.Certificate;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 
@@ -20,7 +24,7 @@ public class JarResource implements ClassLoadingResource {
 
     private final ManifestInfo manifestInfo;
     private final Path jarPath;
-    private volatile ZipFile zipFile;
+    private volatile JarFile zipFile;
 
     public JarResource(ManifestInfo manifestInfo, Path jarPath) {
         this.manifestInfo = manifestInfo;
@@ -54,12 +58,17 @@ public byte[] getResourceData(String resource) {
 
     @Override
     public URL getResourceURL(String resource) {
-        ZipFile zipFile = file();
-        ZipEntry entry = zipFile.getEntry(resource);
+        JarFile zipFile = file();
+        JarEntry entry = zipFile.getJarEntry(resource);
         if (entry == null) {
             return null;
         }
         try {
+            String realName = JarEntries.getRealName(entry);
+            // Avoid ending the URL with / to avoid breaking compatibility
+            if (realName.endsWith("/")) {
+                realName = realName.substring(0, realName.length() - 1);
+            }
             URI jarUri = jarPath.toUri();
             return new URL("jar", null, jarUri.getScheme() + ":" + jarUri.getPath() + "!/" + resource);
         } catch (MalformedURLException e) {
@@ -89,12 +98,12 @@ public ProtectionDomain getProtectionDomain(ClassLoader classLoader) {
         return new ProtectionDomain(codesource, null, classLoader, null);
     }
 
-    private ZipFile file() {
+    private JarFile file() {
         if (zipFile == null) {
             synchronized (this) {
                 if (zipFile == null) {
                     try {
-                        return zipFile = new ZipFile(jarPath.toFile());
+                        return zipFile = JarFiles.create(jarPath.toFile());
                     } catch (IOException e) {
                         throw new RuntimeException("Failed to open " + jarPath, e);
                     }

independent-projects/bootstrap/runner/src/main/java/io/quarkus/bootstrap/runner/SerializedApplication.java

@@ -29,6 +29,8 @@
  */
 public class SerializedApplication {
 
+    public static final String META_INF_VERSIONS = "META-INF/versions/";
+
     private static final int MAGIC = 0XF0315432;
     private static final int VERSION = 1;
 
@@ -160,6 +162,20 @@ private static void writeJar(DataOutputStream out, Path jar) throws IOException
                     //looking at you h2
                     final int index = entry.getName().lastIndexOf('/');
                     dirs.add(entry.getName().substring(0, index));
+
+                    if (entry.getName().startsWith(META_INF_VERSIONS)) {
+                        //multi release jar
+                        //we add all packages here
+                        //they may no be relevant for some versions, but that is fine
+                        String part = entry.getName().substring(META_INF_VERSIONS.length());
+                        int slash = part.indexOf("/");
+                        if (slash != -1) {
+                            final int subIndex = part.lastIndexOf('/');
+                            if (subIndex != slash) {
+                                dirs.add(part.substring(slash + 1, subIndex));
+                            }
+                        }
+                    }
                 }
             }
             if (hasDefaultPackge) {