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

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Quarkus Core Deployment

Name: tessl/maven-io--quarkus--quarkus-core-deployment
Author: tessl

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();
}