All Classes and Interfaces
Class
Description
An additional application archive.
A marker file that if present indicates that a given archive should be treated as an
application archive.
Allows extensions to add classes to the index available via
CombinedIndexBuildItem.Build item that will allow the use of JNDI by default.
Create annotation proxies that can be used as
Recorder parameters.Indicates that a specific container image should be used to generate the AppCDS file
If this build item is generated, then it means that there is a recorder step that can be used as a point at which
the application loading during AppCDS generation can be stopped safely, therefore allowing Quarkus to not have to
stop loading the application in the static init phase which is the default approach for AppCDS generation.
Build item to indicate to the various steps that AppCDS generation
has been requested
A build item containing the result of the AppCDS generation process
Represents an archive that is part of application code.
Makes it possible to identify wiring classes generated for classes from additional hot deployment paths.
The Jandex index of the application root.
A symbolic class that is produced after the startup event has been fired.
Represents a runnable artifact, such as an uberjar or thin jar.
A collection of ASM and Jandex utilities.
The augmentation task that produces the application.
A task that can be used in isolated environments to do a build
This is used currently only to suppress warnings about unknown properties
when the user supplies something like: -Dquarkus.debug.reflection=true
An interface that can be injected to produce
BuildItem instances
This can be injected into either a field or method parameter.Producer class used by the source generated from the annotation processor
Indicates that a given method is a build step that is run at deployment time to
create the runtime output.
Applies configuration to all build steps defined in the same class.
The build systems target directory.
A configuration reader.
The definition of a constant
that can be injected into recorders via their
@Inject-annotated constructor.A class that can be used to record invocations to bytecode so they can be replayed later.
A group of instructions that will always be executed in the same method
A step that must be executed to serialize a complex object
class responsible for splitting the bytecode into smaller methods, to make sure that even large objects and large
numbers of invocations do not put us over the method limit.
This build items holds the set of registered capabilities.
Represents a capability of a core extension.
Represents a technical capability that can be queried by other extensions.
Represents the differences between classes in a dev mode restart.
WARNING: This is not normal quarkus config, this is only read from application.properties.
Utility that dumps bytes from a class to a file - useful for debugging generated classes
Code generation context
Links a
CodeGenProvider instance, an input and output directories for the provider.A set of methods to initialize and execute
CodeGenProviders.Lock that is used to prevent scanning and compiling while code generator is updating sources
There is a race when testing this, where you can see the intermediate empty state of the
file, or where the file time changes twice.
Service providers for this interface are triggered during generate-sources phase of build of Quarkus applications
An index of application classes which is built from archives and dependencies that contain a certain marker file.
This class contains code coming from org.apache.maven.shared.utils.cli.CommandLineUtils.
A set of compiler flags for javac.
A build item that is not part of the standard build, but is only used to generate
example config files and docs.
A pattern-matching mapping of configuration key pattern to value.
Configuration options for application build time configuration usage tracking
and dumping.
Build configuration interceptor that records all the configuration options
and their values that are read during the build.
A writer that persists collected configuration options and their values to a file
Provides an immutable map of options that were read during the build.
Transforms configuration values before they are written to a file
The build item which carries the build time configuration.
The configuration type build item.
Build item that signifies that the interactive console is ready.
Registers all classes for reflection,
that contain a constructor annotated with
@java.beans.ConstructorProperties.Declare that this step comes after the given build item is produced.
The repeatable holder for
Consume.A container for a configuration key path.
Supported Container runtimes
Build Item that can be used to queue shutdown tasks that are run when the
CuratedApplication
is closed.This class is a bit of a hack, it provides a way to pass in the current curratedApplication into the TestExtension
This is used currently only to suppress warnings about unknown properties
when the user supplies something like: -Dquarkus.debug.reflection=true
TODO refactor code to actually use these values
A noop remote dev client, that just polls every second to update the app
This is useful if you are using an external tool such as odo to update your remote pod.
A configuration definition.
Fake connection that can be used to stop a running aesh instance
If you create a console with one of these and then close it Aesh will assume the program is done and exit
Way for maven and gradle plugins to discover if any declared extensions
support quarkus deploy
Object that is used to pass context data from the plugin doing the invocation
into the dev mode process using java serialization.
SPI that can be used by extensions that need to run code in various phases of dev mode
The main entry point for the dev mojo execution
An additional configuration property to set when a dev service sets another, specific configuration property.
Deprecated.
Build item that contains the final results of all configuration.
Deprecated.
BuildItem for running dev services.
A marker build item that indicates, if any instances are provided during the build, the containers started by DevServices
will use a shared network.
Generates a
List<Consumer<BuildChainBuilder>> build chain builder which creates a build step
producing the DevServicesSharedNetworkBuildItem build item.Allows disabling of instrumentation based reload if the changed class matches certain criteria
Allows disabling of instrumentation based reload if the index of changed classes matches certain criteria
Contains the IDE to be opened when a request to open a class is made
Deprecated.
--enable-all-security-services was removed in GraalVM 21.1 https://github.com/oracle/graal/pull/3258Substrate prints incomprehensible and useless 'potential call paths' that look like stack traces
Allows for a handler to be registered when exceptions are logged.
A build item that allows extension to configure the native-image compiler to effectively
ignore certain configuration files in specific jars.
Build item that defines dependencies that should not be indexed.
Carries a predicate that identifies methods that can have annotations which affect
the execution model (
@Blocking, @NonBlocking, @RunOnVirtualThread).Enum that specifies at what time generated bytecode should be run
The main executor for blocking tasks.
Utility class to load build steps, runtime recorders, and configuration roots from a given extension class.
Represents a feature provided by a core extension.
Represents functionality provided by an extension.
Callback for file system change events
The event object that is fired when a file system change is detected.
Watched file event types.
Forces classes that have been registered for reflection using weak semantics, to revert to normal reflection registration
semantics.
Used when resources generated by the build should not end up in the produced runnable artifact,
but in the file system inside the output directory of OutputTargetBuildItem.
Marker used only to ensure that the file system resources where properly written in dev mode.
A generated class that is only applicable to native images.
Deprecated.
in favor of
GlobUtilIdentifies a file from a
reloadable module that, if modified, may result in a hot redeployment when in the dev mode.Contains the set of IDEs that could be potentially linked to project based
on the files present in the project
Contains the set of IDEs that are running as processes
Build item that defines dependencies that should be indexed.
This wrapper is used to index JDK classes on demand.
Represents an initialization task for the application.
A symbolic class that represents that an initialization task has been completed.
A Gizmo
ClassOutput that is able to inject the bytecode directly into the classloader
The ClassLoader passed to the constructor MUST contain a public visibleDefineClass method
This ensures that generating proxies works in any JDK versionIf present, will force the addition of the
-H:+InlineBeforeAnalysis flag during native image buildA build item that provides the ability to detect if the current thread is an IO thread
boolean supplier that returns true if the application is running in development
mode.
boolean supplier that returns true if the application is running in normal
mode.
boolean supplier that returns true if the application is running in normal
mode, but is not a remote dev client.
The main entry point for the local (developer side) of remote dev mode
The main entry point of quarkus:test
boolean supplier that returns true if the application is the local side
of remote dev mode.
boolean supplier that returns true if the application is running in test
mode.
A collection of Jandex utility methods.
This build step builds both the thin jars and uber jars.
Used to register a class for JNI runtime access.
JNI access registration fine-grained to single fields
for a given class.
JNI access registration fine-grained to single methods
for a given class.
A build item that indicates that a Java package should be exported using
'-J--add-exports' option to become visible to native-image
This class is responsible for running a single run of JUnit tests.
Used to register a lambda capturing type in native mode
Indicates the type of launch.
marker build item that extensions can use to force legacy jar creation
A build item that can be used to query the live reload state.
In order for a Native image built app to be able to use localized names of e.g.
We activate additional resources in native-image executable only if user opts
for anything else than what is already the system default.
Establish the default log level of a log category.
Declare that a log filter should be applied to the specified loggerName,
provided the message starts with messageStart.
The log console format build item.
The log file format build item.
A build item for adding additional logging handlers.
The syslog format build item.
A map container.
A metrics provider will iterate over all MetricsFactory consumers,
allowing them to register metrics via bytecode recording
A build item for adding additional named logging handlers.
Supplier that can be used to only run build steps in the
native build.
Supported Builder Image providers/distributions
Do not use directly: use
instead.
Deprecated.
Register a JVM module to be enabled via GraalVM's
--add-modules
argument.Represents a GraalVM
Feature to be passed to native-image through the --features options.A build item that represents a
Proxy definition
that will be required in native mode.A build item that indicates that a static resource should be included in the native image
Indicates that a resource bundle should be included in the native image
A build item that indicates that directory resources should be included in the native image
A build item that indicates that a set of resource paths defined by regular expression patterns or globs should be
included in the native image.
The resolved factory for the native image runner.
A build item that indicates that a security provider should be included in the native image using
'-H:AdditionalSecurityProviders' option
A jar that is build to run the native image
A system property that will be set at native image build time
A build item that indicates the minimal acceptable JDK version
the native-image tool was bundled with.
Supplier that can be used to only run build steps in the
native or native sources builds.
Supplier that can be used to only run build steps in the
native sources build.
A segment of code generation which produces the necessary instructions to load the given object.
Used to capture object substitution information for non-serializable classes.
Holder to keep type info around for compiler.
The location that output artifacts should be created in
TODO: should we just create them in temp directories, and leave it up to the integration to move them where they want?
Indicate that the given produced item is produced only if no other steps produce that item.
Build item that extensions must create to register a package type.
Verifies that the requested package type can actually be produced
This is used currently only to suppress warnings about unknown properties
when the user supplies something like: -Dquarkus.platform.group-id=someGroup
TODO refactor code to actually use these values
Class to be preloaded in static initialization phase of Quarkus.
Extension build steps can produce this if preloading classes is enabled.
Deprecated.
use
ProcessInheritIODisabledBuildItem insteadGenerates a
build chain builder which creates a build step
producing the ProcessInheritIODisabled build itemA build item, which indicates that the
ProcessBuilder.inheritIO() will not work for processes
launched by build steps and instead the build step will have to explicitly stream the newly launched
process' STDOUT/STDERR, if the data generated on the STDOUT/STDERR of the launched process needs to be
made availableGenerates a
build chain builder which creates a build step
producing the ProcessInheritIODisabledBuildItem build itemUtility for
Process related operationsDeclare that this step comes before the given build items are consumed.
The repeatable holder for
Produce.Declare that this step comes before the given build items are consumed, but using weak semantics.
The repeatable holder for
ProduceWeak.Basic configuration needed to generate a proxy of a class.
A factory that can generate proxies of a class.
A subclass of
ClassVisitor that allows carrying around data
that are useful in the context of Quarkus bytecode transformations.ClassWriter which tries to get around ClassNotFoundExceptions related to reflection usage in
getCommonSuperClass.
Class that handles compilation of source files
A build item that represents the raw command line arguments as they were passed to the application.
Indicates that this
BuildStep method will also output recorded bytecode.Indicates that the given class should be instantiated with the constructor with the most parameters
when the object is bytecode recorded.
An injectable utility class that contains methods that can be needed for dealing with recorders.
writes a list of all reflective classes to META-INF, if the quarkus.debug.reflection system property is set
Used to register a class for reflection in native mode
Used to define a condition to register a class for reflection in native mode only when a specific type is reachable
Used by
io.quarkus.deployment.steps.ReflectiveHierarchyStep to determine whether
the final fields of the class should be writable (which they aren't by default)
If any one of the predicates returns true for a class, then ReflectiveHierarchyStep uses that true valueAttempts to register a complete type hierarchy for reflection.
Used by
ReflectiveHierarchyStep to ignore reflection warning deliberatelyThis reloadable file manager handle the class-paths and file locations of separated file manager instances.
A class loader that combines multiple class loaders into one.
The classes loaded by this class loader are associated with this class loader, i.e.
The classes loaded by this class loader are associated with this class loader, i.e.
Represents resources to be removed from a dependency when packaging the application.
Build Item that can be used to queue shutdown tasks that are run when the runtime application shuts down.
Provides a way to register a
ConfigBuilder in RUNTIME.Marker used by Build Steps that consume runtime configuration to ensure that they run after the runtime config has been set
up.
A build item which specifies a configuration default value for run time, which is used to establish a default other
than the one given for
ConfigItem.defaultValue().A build item that carries all the "fake" run time config objects for use by recorders.
A class that will be initialized at runtime in native mode.
A package that will be initialized at runtime in native mode.
A class that will be reinitialized at runtime in native mode.
Represents a Service Provider registration.
A symbolic class that represents a service start.
A marker build item to make Quarkus set the
java.class.path system property.option completer that takes a simple set of possible values
A build item that can be used to register shutdown tasks in runtime recorders.
Configure the various optimization to use
SnapStart
Allows extensions to set a default value for enabling SnapStart.
Marker item to specify that SnapStart is enabled.
A processor handling the various AWS SnapStart optimizations.
special filter that can be used to compress log messages to a status line
This static file manager handle the class-paths and file locations of a single manager instance.
Provides a way to register a
ConfigBuilder in STATIC INIT.A build item for adding the dev stream log via mutiny.
Used to suppress forbidden-apis errors inside for the element it's added to.
Allows extensions to suppress the runtime warning that Quarkus emits on startup when a non-runtime configuration
option is different at runtime than build time.
Represents a system property that will be set immediately on application startup.
This is an optional build item that allows us to track annotations that will define test classes.
This is an optional build item that allows us to track additional test classes that will become beans.
This is an optional build item that allows extensions to distinguish test classes from application classes.
This is used currently only to suppress warnings about unknown properties
when the user supplies something like: -Dquarkus.test.profile=someProfile or -Dquarkus.test.native-image-profile=someProfile
This is an optional build item that represents the current test profile.
Virtual build item that is used to signify that a step must be run to set up
continuous testing
processor that instruments test and application classes to trace the code path that is in use during a test run.
The results of applying bytecode transformation to a class.
Ignore resources when building an Uber Jar
Merge duplicate resources from multiple JARs when building an Uber Jar
marker build item that extensions can use to force uber jar creation
Native-image might not be supported for a particular
extension on a given OS or architecture.
A marker build item that is used to indicate that UPX compression was performed
Common URI path resolution
File system watcher service based on JDK7
WatchService.Indicate that the given produced item is produced only weakly.
Deprecated, for removal: This API element is subject to removal in a future version.
Use WebJarBuildItem and WebJarResultsBuildItem instead.
DevServicesResultBuildItem