use of io.quarkus.bootstrap.app.AugmentAction in project quarkus by quarkusio.
the class QuarkusDeployableContainer method deploy.
@SuppressWarnings("rawtypes")
@Override
public ProtocolMetaData deploy(Archive<?> archive) throws DeploymentException {
old = Thread.currentThread().getContextClassLoader();
if (testClass.get() == null) {
throw new IllegalStateException("Test class not available");
}
Class testJavaClass = testClass.get().getJavaClass();
// some TCK tests embed random libraries such as old versions of Jackson databind
// this breaks quarkus, so we just skip them
boolean skipLibraries = Boolean.getBoolean("io.quarkus.arquillian.skip-libraries");
try {
// Export the test archive
Path tmpLocation = Files.createTempDirectory("quarkus-arquillian-test");
deploymentLocation.set(tmpLocation);
archive.as(ExplodedExporter.class).exportExplodedInto(tmpLocation.toFile());
Path appLocation;
Set<Path> libraries = new HashSet<>();
if (archive instanceof WebArchive) {
// Quarkus does not support the WAR layout and so adapt the layout (similarly to quarkus-war-launcher)
appLocation = tmpLocation.resolve("app").toAbsolutePath();
// WEB-INF/lib -> lib/
if (!skipLibraries) {
if (Files.exists(tmpLocation.resolve("WEB-INF/lib"))) {
Files.move(tmpLocation.resolve("WEB-INF/lib"), tmpLocation.resolve("lib"));
}
}
// WEB-INF/classes -> archive/
if (Files.exists(tmpLocation.resolve("WEB-INF/classes"))) {
Files.move(tmpLocation.resolve("WEB-INF/classes"), appLocation);
} else {
Files.createDirectory(appLocation);
}
// META-INF -> archive/META-INF/
if (Files.exists(tmpLocation.resolve("META-INF"))) {
if (Files.exists(appLocation.resolve("META-INF"))) {
// Target directory not empty.
try (Stream<Path> fileTreeElements = Files.walk(tmpLocation.resolve("META-INF"), 2)) {
fileTreeElements.forEach(p -> {
try {
Files.createFile(p);
} catch (FileAlreadyExistsException faee) {
// Do Nothing
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
} else {
Files.move(tmpLocation.resolve("META-INF"), appLocation.resolve("META-INF"));
}
}
// WEB-INF -> archive/WEB-INF
if (Files.exists(tmpLocation.resolve("WEB-INF"))) {
Files.move(tmpLocation.resolve("WEB-INF"), appLocation.resolve("WEB-INF"));
}
// Collect all libraries
if (Files.exists(tmpLocation.resolve("lib"))) {
try (Stream<Path> libs = Files.walk(tmpLocation.resolve("lib"), 1)) {
libs.forEach((i) -> {
if (i.getFileName().toString().endsWith(".jar")) {
libraries.add(i);
}
});
}
}
} else {
appLocation = tmpLocation;
}
List<Consumer<BuildChainBuilder>> customizers = new ArrayList<>();
// Test class is a bean
customizers.add(new Consumer<BuildChainBuilder>() {
@Override
public void accept(BuildChainBuilder buildChainBuilder) {
buildChainBuilder.addBuildStep(new BuildStep() {
@Override
public void execute(BuildContext context) {
context.produce(AdditionalBeanBuildItem.unremovableOf(testJavaClass));
}
}).produces(AdditionalBeanBuildItem.class).build();
}
});
QuarkusBootstrap.Builder bootstrapBuilder = QuarkusBootstrap.builder().setApplicationRoot(appLocation).setProjectRoot(appLocation).setIsolateDeployment(false).setFlatClassPath(true).setMode(QuarkusBootstrap.Mode.TEST);
for (Path i : libraries) {
bootstrapBuilder.addAdditionalApplicationArchive(new AdditionalDependency(i, false, true));
}
// Path testLocation = PathTestHelper.getTestClassesLocation(testJavaClass);
// bootstrapBuilder.setProjectRoot(PathTestHelper.getTestClassesLocation(testJavaClass));
CuratedApplication curatedApplication = bootstrapBuilder.build().bootstrap();
AugmentAction augmentAction = new AugmentActionImpl(curatedApplication, customizers);
StartupAction app = augmentAction.createInitialRuntimeApplication();
RunningQuarkusApplication runningQuarkusApplication = app.run();
appClassloader.set(runningQuarkusApplication.getClassLoader());
runningApp.set(runningQuarkusApplication);
Thread.currentThread().setContextClassLoader(runningQuarkusApplication.getClassLoader());
// Instantiate the real test instance
testInstance = TestInstantiator.instantiateTest(testJavaClass, runningQuarkusApplication.getClassLoader());
// its pretty bogus
if (Boolean.getBoolean("io.quarkus.arquillian.copy-fields")) {
Class<?> dest = testInstance.getClass();
Class<?> source = testClass.get().getJavaClass();
while (source != Object.class) {
for (Field f : source.getDeclaredFields()) {
try {
if (Modifier.isStatic(f.getModifiers()) && !Modifier.isFinal(f.getModifiers())) {
Field df = dest.getDeclaredField(f.getName());
df.setAccessible(true);
f.setAccessible(true);
df.set(null, f.get(null));
}
} catch (Exception e) {
LOGGER.error("Failed to copy static field", e);
}
}
source = source.getSuperclass();
dest = dest.getSuperclass();
}
}
} catch (Throwable t) {
// clone the exception into the correct class loader
Throwable nt;
ByteArrayOutputStream out = new ByteArrayOutputStream();
try (ObjectOutputStream a = new ObjectOutputStream(out)) {
a.writeObject(t);
a.close();
nt = (Throwable) new ObjectInputStream(new ByteArrayInputStream(out.toByteArray())).readObject();
} catch (Exception e) {
throw new DeploymentException("Unable to start the runtime runner", t);
}
throw new DeploymentException("Unable to start the runtime runner", nt);
} finally {
Thread.currentThread().setContextClassLoader(old);
}
ProtocolMetaData metadata = new ProtocolMetaData();
// TODO: fix this
String testUri = TestHTTPResourceManager.getUri(runningApp.get());
System.setProperty("test.url", testUri);
URI uri = URI.create(testUri);
HTTPContext httpContext = new HTTPContext(uri.getHost(), uri.getPort());
// This is to work around https://github.com/arquillian/arquillian-core/issues/216
httpContext.add(new Servlet("dummy", "/"));
metadata.addContext(httpContext);
return metadata;
}
use of io.quarkus.bootstrap.app.AugmentAction in project quarkus by quarkusio.
the class QuarkusTestExtension method doJavaStart.
private ExtensionState doJavaStart(ExtensionContext context, Class<? extends QuarkusTestProfile> profile) throws Throwable {
TracingHandler.quarkusStarting();
hangDetectionExecutor = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "Quarkus hang detection timer thread");
}
});
String time = "10m";
// config is not established yet
// we can only read from system properties
String sysPropString = System.getProperty(QUARKUS_TEST_HANG_DETECTION_TIMEOUT);
if (sysPropString != null) {
time = sysPropString;
}
hangTimeout = new DurationConverter().convert(time);
hangTaskKey = hangDetectionExecutor.schedule(hangDetectionTask, hangTimeout.toMillis(), TimeUnit.MILLISECONDS);
quarkusTestProfile = profile;
Class<?> requiredTestClass = context.getRequiredTestClass();
Closeable testResourceManager = null;
try {
final LinkedBlockingDeque<Runnable> shutdownTasks = new LinkedBlockingDeque<>();
PrepareResult result = createAugmentor(context, profile, shutdownTasks);
AugmentAction augmentAction = result.augmentAction;
QuarkusTestProfile profileInstance = result.profileInstance;
testHttpEndpointProviders = TestHttpEndpointProvider.load();
StartupAction startupAction = augmentAction.createInitialRuntimeApplication();
Thread.currentThread().setContextClassLoader(startupAction.getClassLoader());
populateDeepCloneField(startupAction);
// must be done after the TCCL has been set
testResourceManager = (Closeable) startupAction.getClassLoader().loadClass(TestResourceManager.class.getName()).getConstructor(Class.class, Class.class, List.class, boolean.class, Map.class, Optional.class).newInstance(requiredTestClass, profile != null ? profile : null, getAdditionalTestResources(profileInstance, startupAction.getClassLoader()), profileInstance != null && profileInstance.disableGlobalTestResources(), startupAction.getDevServicesProperties(), Optional.empty());
testResourceManager.getClass().getMethod("init", String.class).invoke(testResourceManager, profile != null ? profile.getName() : null);
Map<String, String> properties = (Map<String, String>) testResourceManager.getClass().getMethod("start").invoke(testResourceManager);
startupAction.overrideConfig(properties);
hasPerTestResources = (boolean) testResourceManager.getClass().getMethod("hasPerTestResources").invoke(testResourceManager);
populateCallbacks(startupAction.getClassLoader());
populateTestMethodInvokers(startupAction.getClassLoader());
if (profileInstance == null || !profileInstance.runMainMethod()) {
runningQuarkusApplication = startupAction.run(profileInstance == null ? new String[0] : profileInstance.commandLineParameters());
} else {
Class<?> lifecycleManager = Class.forName(ApplicationLifecycleManager.class.getName(), true, startupAction.getClassLoader());
lifecycleManager.getDeclaredMethod("setDefaultExitCodeHandler", Consumer.class).invoke(null, (Consumer<Integer>) integer -> {
});
runningQuarkusApplication = startupAction.runMainClass(profileInstance.commandLineParameters());
}
String patternString = runningQuarkusApplication.getConfigValue("quarkus.test.class-clone-pattern", String.class).orElse("java\\..*");
clonePattern = Pattern.compile(patternString);
TracingHandler.quarkusStarted();
if (hangTaskKey != null) {
hangTaskKey.cancel(false);
hangTimeout = runningQuarkusApplication.getConfigValue(QUARKUS_TEST_HANG_DETECTION_TIMEOUT, Duration.class).orElse(Duration.of(10, ChronoUnit.MINUTES));
hangTaskKey = hangDetectionExecutor.schedule(hangDetectionTask, hangTimeout.toMillis(), TimeUnit.MILLISECONDS);
}
ConfigProviderResolver.setInstance(new RunningAppConfigResolver(runningQuarkusApplication));
RestorableSystemProperties restorableSystemProperties = RestorableSystemProperties.setProperties(Collections.singletonMap("test.url", TestHTTPResourceManager.getUri(runningQuarkusApplication)));
Closeable tm = testResourceManager;
Closeable shutdownTask = new Closeable() {
@Override
public void close() throws IOException {
TracingHandler.quarkusStopping();
try {
runningQuarkusApplication.close();
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
TracingHandler.quarkusStopped();
try {
while (!shutdownTasks.isEmpty()) {
shutdownTasks.pop().run();
}
} finally {
try {
tm.close();
} finally {
restorableSystemProperties.close();
GroovyCacheCleaner.clearGroovyCache();
shutdownHangDetection();
}
}
try {
TestClassIndexer.removeIndex(requiredTestClass);
} catch (Exception ignored) {
}
}
}
};
ExtensionState state = new ExtensionState(testResourceManager, shutdownTask);
return state;
} catch (Throwable e) {
if (!InitialConfigurator.DELAYED_HANDLER.isActivated()) {
activateLogging();
}
try {
if (testResourceManager != null) {
testResourceManager.close();
}
} catch (Exception ex) {
e.addSuppressed(ex);
}
throw e;
} finally {
if (originalCl != null) {
Thread.currentThread().setContextClassLoader(originalCl);
}
}
}
use of io.quarkus.bootstrap.app.AugmentAction in project quarkus by quarkusio.
the class IntegrationTestUtil method handleDevServices.
static ArtifactLauncher.InitContext.DevServicesLaunchResult handleDevServices(ExtensionContext context, boolean isDockerAppLaunch) throws Exception {
Class<?> requiredTestClass = context.getRequiredTestClass();
Path testClassLocation = getTestClassesLocation(requiredTestClass);
final Path appClassLocation = getAppClassLocationForTestLocation(testClassLocation.toString());
final PathList.Builder rootBuilder = PathList.builder();
if (!appClassLocation.equals(testClassLocation)) {
rootBuilder.add(testClassLocation);
// if test classes is a dir, we should also check whether test resources dir exists as a separate dir (gradle)
// TODO: this whole app/test path resolution logic is pretty dumb, it needs be re-worked using proper workspace discovery
final Path testResourcesLocation = PathTestHelper.getResourcesForClassesDirOrNull(testClassLocation, "test");
if (testResourcesLocation != null) {
rootBuilder.add(testResourcesLocation);
}
}
final QuarkusBootstrap.Builder runnerBuilder = QuarkusBootstrap.builder().setIsolateDeployment(true).setMode(QuarkusBootstrap.Mode.TEST);
final Path projectRoot = Paths.get("").normalize().toAbsolutePath();
runnerBuilder.setProjectRoot(projectRoot);
runnerBuilder.setTargetDirectory(PathTestHelper.getProjectBuildDir(projectRoot, testClassLocation));
rootBuilder.add(appClassLocation);
final Path appResourcesLocation = PathTestHelper.getResourcesForClassesDirOrNull(appClassLocation, "main");
if (appResourcesLocation != null) {
rootBuilder.add(appResourcesLocation);
}
// If gradle project running directly with IDE
if (System.getProperty(BootstrapConstants.SERIALIZED_TEST_APP_MODEL) == null) {
ApplicationModel model = BuildToolHelper.enableGradleAppModelForTest(projectRoot);
if (model != null && model.getApplicationModule() != null) {
final ArtifactSources testSources = model.getApplicationModule().getTestSources();
if (testSources != null) {
for (SourceDir src : testSources.getSourceDirs()) {
if (!Files.exists(src.getOutputDir())) {
final Path classes = src.getOutputDir();
if (!rootBuilder.contains(classes)) {
rootBuilder.add(classes);
}
}
}
}
for (SourceDir src : model.getApplicationModule().getMainSources().getSourceDirs()) {
if (!Files.exists(src.getOutputDir())) {
final Path classes = src.getOutputDir();
if (!rootBuilder.contains(classes)) {
rootBuilder.add(classes);
}
}
}
}
} else if (System.getProperty(BootstrapConstants.OUTPUT_SOURCES_DIR) != null) {
final String[] sourceDirectories = System.getProperty(BootstrapConstants.OUTPUT_SOURCES_DIR).split(",");
for (String sourceDirectory : sourceDirectories) {
final Path directory = Paths.get(sourceDirectory);
if (Files.exists(directory) && !rootBuilder.contains(directory)) {
rootBuilder.add(directory);
}
}
}
runnerBuilder.setApplicationRoot(rootBuilder.build());
CuratedApplication curatedApplication = runnerBuilder.setTest(true).build().bootstrap();
Index testClassesIndex = TestClassIndexer.indexTestClasses(requiredTestClass);
// we need to write the Index to make it reusable from other parts of the testing infrastructure that run in different ClassLoaders
TestClassIndexer.writeIndex(testClassesIndex, requiredTestClass);
Map<String, String> propertyMap = new HashMap<>();
AugmentAction augmentAction;
String networkId = null;
if (isDockerAppLaunch) {
// when the application is going to be launched as a docker container, we need to make containers started by DevServices
// use a shared network that the application container can then use as well
augmentAction = curatedApplication.createAugmentor("io.quarkus.deployment.builditem.DevServicesSharedNetworkBuildItem$Factory", Collections.emptyMap());
} else {
augmentAction = curatedApplication.createAugmentor();
}
augmentAction.performCustomBuild(NativeDevServicesHandler.class.getName(), new BiConsumer<String, String>() {
@Override
public void accept(String s, String s2) {
propertyMap.put(s, s2);
}
}, DevServicesLauncherConfigResultBuildItem.class.getName());
boolean manageNetwork = false;
if (isDockerAppLaunch) {
// or else we run into various ClassLoader problems
try {
Class<?> networkClass = curatedApplication.getAugmentClassLoader().loadClass("org.testcontainers.containers.Network");
Object sharedNetwork = networkClass.getField("SHARED").get(null);
networkId = (String) networkClass.getMethod("getId").invoke(sharedNetwork);
} catch (Exception e) {
// use the network the use has specified or else just generate one if none is configured
Config config = LauncherUtil.installAndGetSomeConfig();
Optional<String> networkIdOpt = config.getOptionalValue("quarkus.test.container.network", String.class);
if (networkIdOpt.isPresent()) {
networkId = networkIdOpt.get();
} else {
networkId = "quarkus-integration-test-" + RandomStringUtils.random(5, true, false);
manageNetwork = true;
}
}
}
DefaultDevServicesLaunchResult result = new DefaultDevServicesLaunchResult(propertyMap, networkId, manageNetwork, curatedApplication);
createNetworkIfNecessary(result);
return result;
}
use of io.quarkus.bootstrap.app.AugmentAction in project quarkus by quarkusio.
the class IsolatedDevModeMain method accept.
// the main entry point, but loaded inside the augmentation class loader
@Override
public void accept(CuratedApplication o, Map<String, Object> params) {
// setup the dev mode thread pool for NIO
System.setProperty("java.nio.channels.DefaultThreadPool.threadFactory", "io.quarkus.dev.io.NioThreadPoolThreadFactory");
Timing.staticInitStarted(o.getBaseRuntimeClassLoader(), false);
// https://github.com/quarkusio/quarkus/issues/9748
// if you have an app with all daemon threads then the app thread
// may be the only thread keeping the JVM alive
// during the restart process when this thread is stopped then
// the JVM will die
// we start this thread to keep the JVM alive until the shutdown hook is run
// even for command mode we still want the JVM to live until it receives
// a signal to make the 'press enter to restart' function to work
new Thread(new Runnable() {
@Override
public void run() {
try {
shutdownLatch.await();
} catch (InterruptedException ignore) {
}
}
}, "Quarkus Devmode keep alive thread").start();
try {
curatedApplication = o;
Object potentialContext = params.get(DevModeContext.class.getName());
if (potentialContext instanceof DevModeContext) {
context = (DevModeContext) potentialContext;
} else {
// this was from the external class loader
// we need to copy it into this one
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(out);
oo.writeObject(potentialContext);
context = (DevModeContext) new ObjectInputStream(new ByteArrayInputStream(out.toByteArray())).readObject();
}
augmentAction = new AugmentActionImpl(curatedApplication, Collections.singletonList(new Consumer<BuildChainBuilder>() {
@Override
public void accept(BuildChainBuilder buildChainBuilder) {
buildChainBuilder.addBuildStep(new BuildStep() {
@Override
public void execute(BuildContext context) {
// we need to make sure all hot reloadable classes are application classes
context.produce(new ApplicationClassPredicateBuildItem(new Predicate<String>() {
@Override
public boolean test(String s) {
QuarkusClassLoader cl = (QuarkusClassLoader) Thread.currentThread().getContextClassLoader();
// if the class file is present in this (and not the parent) CL then it is an application class
List<ClassPathElement> res = cl.getElementsWithResource(s.replace('.', '/') + ".class", true);
return !res.isEmpty();
}
}));
}
}).produces(ApplicationClassPredicateBuildItem.class).build();
}
}), Collections.emptyList());
List<CodeGenData> codeGens = new ArrayList<>();
QuarkusClassLoader deploymentClassLoader = curatedApplication.createDeploymentClassLoader();
for (DevModeContext.ModuleInfo module : context.getAllModules()) {
if (!module.getSourceParents().isEmpty() && module.getPreBuildOutputDir() != null) {
// it's null for remote dev
codeGens.addAll(CodeGenerator.init(deploymentClassLoader, module.getSourceParents(), Paths.get(module.getPreBuildOutputDir()), Paths.get(module.getTargetDir()), sourcePath -> module.addSourcePathFirst(sourcePath.toAbsolutePath().toString())));
}
}
RuntimeUpdatesProcessor.INSTANCE = setupRuntimeCompilation(context, (Path) params.get(APP_ROOT), (DevModeType) params.get(DevModeType.class.getName()));
if (RuntimeUpdatesProcessor.INSTANCE != null) {
RuntimeUpdatesProcessor.INSTANCE.checkForFileChange();
RuntimeUpdatesProcessor.INSTANCE.checkForChangedClasses(true);
}
firstStart(deploymentClassLoader, codeGens);
// doStart(false, Collections.emptySet());
if (deploymentProblem != null || RuntimeUpdatesProcessor.INSTANCE.getCompileProblem() != null) {
if (context.isAbortOnFailedStart()) {
throw new RuntimeException(deploymentProblem == null ? RuntimeUpdatesProcessor.INSTANCE.getCompileProblem() : deploymentProblem);
}
}
shutdownThread = new Thread(new Runnable() {
@Override
public void run() {
shutdownLatch.countDown();
synchronized (DevModeMain.class) {
if (runner != null) {
try {
close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}, "Quarkus Shutdown Thread");
Runtime.getRuntime().addShutdownHook(shutdownThread);
} catch (Exception e) {
close();
throw new RuntimeException(e);
}
}
use of io.quarkus.bootstrap.app.AugmentAction in project quarkus by quarkusio.
the class PackageAppTestBase method testBootstrap.
@Override
protected void testBootstrap(QuarkusBootstrap creator) throws Exception {
System.setProperty("quarkus.package.type", "legacy-jar");
try {
CuratedApplication curated = creator.bootstrap();
assertAppModel(curated.getApplicationModel());
final String[] expectedExtensions = expectedExtensionDependencies();
if (expectedExtensions != null) {
assertExtensionDependencies(curated.getApplicationModel(), expectedExtensions);
}
assertDeploymentDeps(curated.getApplicationModel().getDependencies().stream().filter(d -> d.isDeploymentCp() && !d.isRuntimeCp()).map(d -> new ArtifactDependency(d)).collect(Collectors.toSet()));
AugmentAction action = curated.createAugmentor();
AugmentResult outcome = action.createProductionApplication();
final Path libDir = outcome.getJar().getLibraryDir();
assertTrue(Files.isDirectory(libDir));
final Set<String> actualLib = new HashSet<>();
try (Stream<Path> stream = Files.list(libDir)) {
final Iterator<Path> i = stream.iterator();
while (i.hasNext()) {
actualLib.add(i.next().getFileName().toString());
}
}
final Path runnerJar = outcome.getJar().getPath();
assertTrue(Files.exists(runnerJar));
try (JarFile jar = new JarFile(runnerJar.toFile())) {
final Attributes mainAttrs = jar.getManifest().getMainAttributes();
// assert the main class
assertEquals(MAIN_CLS, mainAttrs.getValue("Main-Class"));
// assert the Class-Path contains all the entries in the lib dir
final String cp = mainAttrs.getValue("Class-Path");
assertNotNull(cp);
String[] cpEntries = Arrays.stream(cp.trim().split("\\s+")).filter(s -> !s.trim().isEmpty()).toArray(String[]::new);
assertEquals(actualLib.size(), cpEntries.length);
for (String entry : cpEntries) {
assertTrue(entry.startsWith(LIB_PREFIX));
assertTrue(actualLib.contains(entry.substring(LIB_PREFIX.length())));
}
}
List<String> missingEntries = Collections.emptyList();
for (String entry : expectedLib) {
if (!actualLib.remove(entry)) {
if (missingEntries.isEmpty()) {
missingEntries = new ArrayList<>();
}
missingEntries.add(entry);
}
}
StringBuilder buf = null;
if (!missingEntries.isEmpty()) {
buf = new StringBuilder();
buf.append("Missing entries: ").append(missingEntries.get(0));
for (int i = 1; i < missingEntries.size(); ++i) {
buf.append(", ").append(missingEntries.get(i));
}
}
if (!actualLib.isEmpty()) {
if (buf == null) {
buf = new StringBuilder();
} else {
buf.append("; ");
}
final Iterator<String> i = actualLib.iterator();
buf.append("Extra entries: ").append(i.next());
while (i.hasNext()) {
buf.append(", ").append(i.next());
}
}
if (buf != null) {
fail(buf.toString());
}
} finally {
System.clearProperty("quarkus.package.type");
}
}
Aggregations