All Classes and Interfaces
Class
Description
Abstract deployment unit processors used to process
ComponentDescription instances.Class that provides common functionality required by processors that process environment information from deployment descriptors.
Superclass for EE annotation processors that attach their information to the EEClassDescription via
ClassAnnotationInformationFoundation for processors which binds EE platform common resources, to all EE module and comp naming contexts.
A helper class for security deployment processors
Represents a piece of component metadata
DeploymentUnitProcessor responsible for determining if property replacement should be
done on Jakarta Enterprise Beans annotations.The app client handler for jboss-all.xml
Processor that aggregates all module descriptions visible to the deployment in an EEApplicationClasses structure.
Processor that sets up application clients.
Deployment processor that deploys a naming context for the current application.
Deployment processor responsible for finding @AroundInvoke annotated methods in classes within a deployment.
EE related attachments.
EE related attachments.
A basic component implementation.
A service for creating a component.
An abstract base component instance.
ProfileParsingCompletionHandler that installs a default Jakarta Bean Validation extension and subsystem if the
profile included a legacy EE subsystem version but not Jakarta Bean Validation subsystem.A binding into JNDI.
An annotation information factory that simply returns true if the annotation is present
Class level information about the annotations present on a particular class.
Abstract factory that can produce a
ClassAnnotationInformationthrowaway utility class for traversing a class configuration from most general superclass down
A context handle factory which is responsible for saving and setting proper classloading context.
Common contract for an EE component.
Class that represents an instance of a component client.
The construction parameter set passed in to an abstract component.
A configurator for components.
An exception relating to a problem with the creation of an EE component.
A factory for component creation which allows component behavior customization.
A description of a generic Jakarta EE component.
An instance of a Jakarta EE component.
A factory to create interceptors per ComponentInstance instance.
A factory to create interceptors that are tied to a component instance.
Exception indicating that a component receiving a method call has stopped.
A component's naming context operation mode.
Registry that can be used to create a fully injected class instance.
Service wrapper for a
Component which starts and stops the component instance.An injection source which injects a component based upon its type.
A component view.
Manages context handle factories, it is used by EE Context Services to save the invocation context.
The interceptor responsible for managing the current
ConcurrentContext.A service holding a concurrent context.
MSC service names for EE's concurrent resources.
The factory responsible for creating the context handles with the current context saved
Injection source that can be used to bind a potentially empty context
The
ResourceDefinitionAnnotationProcessor for ContextServiceDefinition.The
ResourceDefinitionDescriptorProcessor for ContextServiceDefinition.The
ResourceDefinitionInjectionSource for ContextServiceDefinitionAn extension of Jakarta EE RI
ContextServiceImpl, which properly supports a security manager.Service responsible for managing a context service impl's lifecycle.
The configuration for a Context Service, which indicates if a context type should be cleared, propagated or unchanged.
The builder class.
Class that manages the control point for executor services
The
DeploymentUnitProcessor which adds the EE subsystem default bindings configuration to EE module descriptions.The resource definition wrt EE default bindings configuration.
The default context setup provider.
DeploymentUnitProcessor responsible for setting the default ear subdeployments isolation for each .ear
deployment unit.A supplier which delegates to other supplier if it is configured.
DependencyConfigurator<T extends org.jboss.msc.service.Service>
A configurator for a service dependency.
The environment as read from a deployment descriptor
Helper class for dealing with the
Attachments#RESOURCE_ROOT_TYPE attachment.Deployment descriptor that resolves interceptor methods defined in ejb-jar.xml that could not be resolved at
DD parse time.
DeploymentUnitProcessor responsible for determining if
property replacement should be done on EE spec descriptors.Utility class for working with method descriptors
The Java EE6 spec and Enterprise Beans 3.1 spec contradict each other on what the "application-name" semantics are.
Processor which ensures that subdeployments of an EAR all synchronize before the next phase.
Processor responsible for detecting and marking EAR file deployments.
A service that creates JACC permissions for an ear deployment
Deployment processor responsible for parsing the application.xml file of an ear.
Handles ear deployments
Deployment processor responsible for detecting EAR deployments and putting setting up the basic structure.
The EE10 ContextHandleFactory, which should replace the legacy one once all impls are migrated.
Processes Jakarta Enterprise Beans annotations and attaches them to the
EEModuleClassDescriptionAllows a deployment to get old of class descriptions from all sub deployments it has access to.
The capabilities provided by and required by this subsystem.
Cleans up references to EE structures in the deployment unit
The DUP responsible for the base concurrent context configuration setup.
Processor responsible for binding the default EE concurrency resources to the naming context of EE modules/components.
A processor which sets up the default Jakarta EE permission set.
The jndi names for the default EE bindings.
Examines a deployment unit and its top level parent to check for any distinct-name that's configured in the
deployment descriptor(s) of the deployment units.
JBossAS domain extension used to initialize the ee subsystem handlers and associated classes.
Warning this class consists of generated code.
The description of a (possibly annotated) class in an EE module.
TODO: do we still need this?
Deployment processor responsible for creating a
EEModuleConfiguration from a EEModuleDescription and
populating it with component and class configurationsClass that is responsible for resolving name conflicts.
User: jpai
User: jpai
Handler for adding the ee subsystem.
Versions of the EE subsystem model
ResourceDefinition for the EE subsystem's root management resource.Handles the "write-attribute" operation for the EE subsystem.
Metadata for configurations contained in jboss-ejb-client.xml descriptor
A deployment unit processor which parses jboss-ejb-client.xml in top level deployments.
Processor that only runs for ear deployments where no application.xml is provided.
A description of an env-entry.
An injection of a fixed value.
A deployment processor that prepares the global directories that are going to be used as dependencies in a deployment.
This service does the required steps to add a directory as a deployment dependency and as an
ExternalModule.The resource definition for global-directory child resource in EE subsystem.
Service responsible creating a
GlobalDirectory which contains the information of a configured global directory.Dependency processor that adds modules defined in the global-modules section of
the configuration to all deployments.
AttributeDefinition implementation for the "global-modules" attribute.Processor responsible for binding java:comp/InAppClientContainer
Sets up dependencies for the next phase if initialize in order is set.
A simple EE-style namespace context selector which uses injected services for the contexts.
A configuration for an injection source.
A resolution context for the injection source.
An injection target field or method in a class.
Utility class for injection framework.
Processor responsible for binding java:comp/InstanceName
Processor that takes interceptor information from the class description and applies it to components
Post class loading description of an interceptor class.
A description of an
@Interceptor annotation value or its equivalent
deployment descriptor construct.Class that represents the environment entries of an interceptor, defined in the interceptors section
of ejb-jar.xml.
Class that maintains interceptor ordering for various interceptor chains
Marker enum that can be used to identify special types of invocations
A
DeploymentUnitProcessor for Jakarta Authorization policies.A service for Jakarta Authorization policies
Deployment processor which adds the Jakarta EE APIs to EE deployments
Sets and restores the
java: contextsDeployment processor responsible for finding @PostConstruct and @PreDestroy annotated methods.
A binding which gets its value from another JNDI binding.
Deployment unit processor responsible for scanning a deployment to find classes with
jakarta.annotation.ManagedBean annotations.Component descriptor for
jakarta.annotation.ManagedBean managed beans.User: jpai
Processor that only runs for ear deployments where no application.xml is provided.
The
ResourceDefinitionAnnotationProcessor for ManagedExecutorDefinition.The
ResourceDefinitionDescriptorProcessor for ManagedExecutorDefinition.The
ResourceDefinitionInjectionSource for ManagedExecutorDefinition.Periodic hung task termination service for managed executors.
Runtime stats from an executor.
The managed executor service resource's runtime metrics attribute names and definitions.
Operation step handler that expose a capability's metrics, through its service.
Service responsible for creating, starting and stopping a ManagedExecutorServiceImpl.
Operation that manually terminates a managed executor's hung tasks, through its capability service.
A managed executor with support for hung threads.
The
ResourceDefinitionAnnotationProcessor for ManagedScheduledExecutorDefinition.The
ResourceDefinitionDescriptorProcessor for ManagedScheduledExecutorDefinition.The
ResourceDefinitionInjectionSource for ManagedScheduledExecutorDefinition.WildFly's extension of
ManagedScheduledExecutorServiceImpl.Service responsible for creating, starting and stopping a ManagedScheduledExecutorServiceImpl.
The
ResourceDefinitionAnnotationProcessor for ManagedThreadFactoryDefinition.The
ResourceDefinitionDescriptorProcessor for ManagedThreadFactoryDefinition.The
ResourceDefinitionInjectionSource for ManagedThreadFactoryDefinition.ManagedThreadFactory implementation ensuring SecurityIdentity propagation into new threads.Implementation of
InjectionSource responsible for finding a message destinationProcessor that resolves all message destinations.
Marker class used to set/get the metadata-complete status of the deployment.
Class which can turn a pre-runtime description of annotations into a runtime description.
Deployment processor that deploys a naming context for the current module.
Processor that sets up JNDI bindings that are owned by the module.
A configurator which adds interceptors to the component which establish the naming context.
An interceptor which imposes the given namespace context selector.
The context handle factory responsible for saving and setting the naming context.
A context handle without invocation context to set.
Container for an ordered list of object.
The context handle factory responsible for setting EE setup actions in the invocation context.
An invocation handler for a component proxy.
The Wildfly's EE context handle.
The foundation to create processors wrt deployment of classes annotated with EE Resource Definitions, as defined by EE.5.18.
Utility class to help handle resource definition annotation elements
Foundation for resource definition deployment descriptor processors.
The abstract InjectionSource for EE Resource Definitions.
Deployment processor responsible for analyzing each attached
ComponentDescription instance to configure
required resource injection configurations.A configuration for resource injection.
Represents an object that has a descriptor based JNDI environment.
Deployment processor that sets up env-entry, resource-ref and resource-env-ref bindings
DUP that adds the to the deployment, and adds the bean validation resolvers.
Runtime metadata about the annotations that are present on a particular class
A wrapper for a
TransactionSetupProvider stored in a service, allowing deserialization through MSC.The Wildfly's EE context handle that sets a saved invocation context.
Countdown tracker with capabilities similar to SE CountDownLatch, but allowing threads
to mark and unmark themselves as privileged.
The context handle factory responsible for saving and setting the context for a deployement's ThreadContextProvider.
FIXME *FOLLOW UP* delete unused TransactionLeakContextHandleFactory and TransactionSetupProviderImpl, and deactivate unused logger msgs
A context handle factory which is responsible for handling the context type ContextServiceDefinition.TRANSACTION.
A context handle factory which is responsible for preventing transaction leaks.
The transaction setup provider handles transaction suspend/resume.
A configuration of a component view.
A configurator for views.
A description of a view.
Factory that can be used to customize a views proxy creation
TODO: this needs to be thought through a bit more
A managed reference factory for a component view.
The bridge injector for binding views into JNDI.
Interface used to allow the proxy to support serialization.