or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

build-system.mdconfiguration.mddev-mode.mdindex.mdpackaging.mdutilities.md
tile.json

tessl/maven-io--quarkus--quarkus-core-deployment

Core deployment-time APIs and infrastructure for building Quarkus applications with native image support and development-time features

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/io.quarkus/quarkus-core-deployment@3.23.x

To install, run

npx @tessl/cli install tessl/maven-io--quarkus--quarkus-core-deployment@3.23.0

index.mddocs/

Quarkus Core Deployment

Quarkus Core Deployment provides the fundamental deployment-time APIs and infrastructure for building Quarkus applications. It enables Quarkus's container-first approach with support for native compilation via GraalVM, development-time features like hot reloading, and a comprehensive build system for creating cloud-native Java applications with minimal footprint and lightning-fast startup times.

Package Information

  • Package Name: io.quarkus:quarkus-core-deployment
  • Package Type: Maven
  • Language: Java
  • Installation: Add to your Maven pom.xml:
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-core-deployment</artifactId>
    <version>3.23.0</version>
</dependency>

Core Imports

// Main augmentation engine
import io.quarkus.deployment.QuarkusAugmentor;
import io.quarkus.deployment.BuildResult;

// Build step annotations
import io.quarkus.deployment.annotations.BuildStep;
import io.quarkus.deployment.annotations.BuildProducer;
import io.quarkus.deployment.annotations.Record;
import io.quarkus.deployment.annotations.ExecutionTime;

// Core build items
import io.quarkus.deployment.builditem.ApplicationArchivesBuildItem;
import io.quarkus.deployment.builditem.CapabilityBuildItem;
import io.quarkus.deployment.builditem.FeatureBuildItem;
import io.quarkus.deployment.builditem.LaunchModeBuildItem;

// Application archives and capabilities
import io.quarkus.deployment.ApplicationArchive;
import io.quarkus.deployment.Capabilities;
import io.quarkus.deployment.Capability;

Basic Usage

// Creating an augmentor for build processing
QuarkusAugmentor augmentor = QuarkusAugmentor.builder()
    .setRoot(applicationRoot)
    .addBuildChainCustomizer(chainCustomizer)
    .build();

BuildResult result = augmentor.run();

// Example build step for extension development
@BuildStep
CapabilityBuildItem capability() {
    return new CapabilityBuildItem(Capability.REST);
}

@BuildStep
void registerFeature(BuildProducer<FeatureBuildItem> features) {
    features.produce(new FeatureBuildItem(Feature.REST));
}

// Recording runtime initialization code
@BuildStep
@Record(ExecutionTime.RUNTIME_INIT)
void configureRuntime(MyRecorder recorder, 
                     LaunchModeBuildItem launchMode) {
    recorder.initialize(launchMode.getLaunchMode());
}

Architecture

The Quarkus Core Deployment module follows a producer-consumer build system architecture:

  • Build Steps: Methods annotated with @BuildStep that form the build chain
  • Build Items: Immutable data objects passed between build steps
  • Augmentor: Orchestrates the entire build process
  • Recorders: Generate bytecode for runtime execution
  • Archives: Represent application and dependency code

Core Components

// Main augmentation orchestrator
class QuarkusAugmentor {
    static Builder builder();
    BuildResult run() throws Exception;
    
    static class Builder {
        Builder setRoot(PathCollection root);
        Builder addBuildChainCustomizer(Consumer<BuildChainBuilder> customizer);
        QuarkusAugmentor build();
    }
}

// Build execution result
class BuildResult {
    List<Consumer<BuildChainBuilder>> getBuildChainCustomizers();
    ClassLoader getBaseRuntimeClassLoader();
}

Application Archives

interface ApplicationArchive {
    IndexView getIndex();
    PathCollection getRootDirectories();
    PathCollection getResolvedPaths();
    ArtifactKey getKey();
    ResolvedDependency getResolvedDependency();
    <T> T apply(Function<OpenPathTree, T> func);
    void accept(Consumer<OpenPathTree> func);
    Path getChildPath(String path);
}

Capabilities Management

class Capabilities extends SimpleBuildItem {
    Set<String> getCapabilities();
    boolean isPresent(String capability);
    boolean isMissing(String capability);
    boolean isCapabilityWithPrefixPresent(String capabilityPrefix);
}

interface Capability {
    String QUARKUS_PREFIX = "io.quarkus";
    String CDI = "io.quarkus.cdi";
    String REST = "io.quarkus.rest";
    String SECURITY = "io.quarkus.security";
    String HIBERNATE_ORM = "io.quarkus.hibernate.orm";
    String KAFKA_CLIENT = "io.quarkus.kafka.client";
    // Additional capability constants...
}

Capabilities

Build System Integration

Core build step annotations, build item management, and the producer-consumer dependency model that powers Quarkus's build chain.

@interface BuildStep {
    Class<? extends BooleanSupplier>[] onlyIf() default {};
    Class<? extends BooleanSupplier>[] onlyIfNot() default {};
}

interface BuildProducer<T extends BuildItem> {
    void produce(T item);
    void produce(Collection<T> items);
}

@interface Record {
    ExecutionTime value() default ExecutionTime.RUNTIME_INIT;
    boolean optional() default false;
    boolean useIdentityComparisonForParameters() default false;
}

enum ExecutionTime {
    STATIC_INIT,
    RUNTIME_INIT
}

Build System

Configuration Management

Build-time and runtime configuration processing, type-safe configuration binding, and configuration root definitions.

class BuildTimeConfigurationReader {
    static RunTimeConfigurationGenerator.ReadResult readConfiguration(
        Path applicationRoot,
        Path outputDirectory,
        ConfigMappingContext configMappingContext,
        LaunchMode launchMode
    );
}

class RunTimeConfigurationGenerator {
    static void generate(ReadResult readResult, 
                        ClassOutput classOutput,
                        LaunchMode launchMode);
    
    static class ReadResult {
        Config getConfig();
        Set<String> getPropertyNames();
    }
}

Configuration

Development Mode Support

Hot reloading, file watching, compilation providers, and development services for enhanced developer experience.

class RuntimeUpdatesProcessor {
    static RuntimeUpdatesProcessor INSTANCE;
    
    boolean doScan(boolean userInitiated, boolean forceRestart);
    void addHotReplacementSetup(HotReplacementSetup service);
    ClassScanResult checkForChangedClasses();
}

interface CompilationProvider {
    Set<String> handledExtensions();
    void compile(Set<File> filesToCompile, Context context);
    
    interface Context {
        Path getSourceDirectory();
        Path getOutputDirectory();
        ClassLoader getClasspathClassLoader();
    }
}

class DevModeContext {
    List<ModuleInfo> getAllModules();
    Path getApplicationRoot();
    String[] getArgs();
    LaunchMode getLaunchMode();
}

Development Mode

Application Packaging

JAR building, native image compilation, container image creation, and deployment artifact generation.

class PackageConfig {
    PackageType type = PackageType.JAR;
    String outputName;
    String outputDirectory;
    boolean createAppcds = true;
    AppcdsConfig appcds;
    
    enum PackageType {
        JAR, LEGACY_JAR, FAST_JAR, NATIVE, NATIVE_SOURCES, UBER_JAR, MUTABLE_JAR
    }
}

class NativeConfig {
    boolean enabled = false;
    List<String> additionalBuildArgs;
    String builderImage = "quay.io/quarkus/ubi-quarkus-mandrel-builder-image";
    ContainerRuntimeConfig containerRuntime;
    String graalvmHome;
}

class JarBuildItem extends SimpleBuildItem {
    Path getPath();
    PackageType getType();
    Path getLibraryDir();
}

Packaging

Utilities and Helpers

Reflection utilities, service loading helpers, file system operations, and container runtime detection.

class ReflectUtil {
    static Method getMethod(Class<?> clazz, String name, Class<?>... parameterTypes);
    static Field getField(Class<?> clazz, String name);
    static <T> T newInstance(Class<T> clazz);
    static Object invoke(Method method, Object instance, Object... args);
}

class ServiceUtil {
    static <T> List<T> classPathServices(Class<T> serviceType, ClassLoader classLoader);
    static <T> Optional<T> classPathService(Class<T> serviceType, ClassLoader classLoader);
}

class FileUtil {
    static void copyFile(Path source, Path target);
    static boolean isDirectoryEmpty(Path directory);
    static void deleteDirectory(Path directory);
    static String relativize(Path base, Path child);
}

Utilities

Types

Build Items

// Base classes for build items
abstract class SimpleBuildItem extends BuildItem {}
abstract class MultiBuildItem extends BuildItem {}

// Core application build items
class ApplicationArchivesBuildItem extends SimpleBuildItem {
    ApplicationArchive getRootArchive();
    Collection<ApplicationArchive> getApplicationArchives();
    Set<ApplicationArchive> getAllApplicationArchives();
    ApplicationArchive containingArchive(String className);
    ApplicationArchive containingArchive(DotName className);
}

class CapabilityBuildItem extends MultiBuildItem {
    String getName();
    String getProvider();
}

class FeatureBuildItem extends MultiBuildItem {
    String getName();
}

class LaunchModeBuildItem extends SimpleBuildItem {
    LaunchMode getLaunchMode();
    Optional<DevModeType> getDevModeType();
    boolean isNotLocalDevModeType();
    boolean isAuxiliaryApplication();
    boolean isTest();
}

class MainClassBuildItem extends SimpleBuildItem {
    String getClassName();
}

Core Enums

enum Feature {
    AGROAL("agroal"),
    AMAZON_LAMBDA("amazon-lambda"),
    CDI("cdi"),
    HIBERNATE_ORM("hibernate-orm"),
    KAFKA_CLIENT("kafka-client"),
    KUBERNETES("kubernetes"),
    REST("rest"),
    SECURITY("security");
    // Additional features...
    
    String getName();
}

enum LaunchMode {
    NORMAL,
    DEVELOPMENT,
    TEST;
}

enum DevModeType {
    LOCAL,
    REMOTE_LOCAL_SIDE,
    REMOTE_SERVER_SIDE
}

Native Image Build Items

class ReflectiveClassBuildItem extends MultiBuildItem {
    String getClassName();
    boolean isConstructors();
    boolean isMethods();
    boolean isFields();
    boolean isWeak();
}

class NativeImageResourceBuildItem extends MultiBuildItem {
    List<String> getResources();
}

class RuntimeInitializedClassBuildItem extends MultiBuildItem {
    String getClassName();
}

class JniRuntimeAccessBuildItem extends MultiBuildItem {
    boolean isConstructors();
    boolean isMethods();
    boolean isFields();
    String getClassName();
}