/**
* {@inheritDoc}
*
* @see org.jboss.as.controller.Extension#initialize(org.jboss.as.controller.ExtensionContext)
*/
@Override
public void initialize(ExtensionContext context) {
// IMPORTANT: Management API version != xsd version! Not all Management API changes result in
// XSD changes
SubsystemRegistration subsystem =
context.registerSubsystem(
SUBSYSTEM_NAME,
MANAGEMENT_API_MAJOR_VERSION,
MANAGEMENT_API_MINOR_VERSION,
MANAGEMENT_API_MICRO_VERSION);
// Create the path resolver handler
final ResolvePathHandler resolvePathHandler;
if (context.getProcessType().isServer()) {
resolvePathHandler =
ResolvePathHandler.Builder.of(context.getPathManager())
.setPathAttribute(FileStoreResource.PATH)
.setRelativeToAttribute(FileStoreResource.RELATIVE_TO)
.build();
} else {
resolvePathHandler = null;
}
subsystem.registerSubsystemModel(new InfinispanSubsystemRootResource(resolvePathHandler));
subsystem.registerXMLElementWriter(new InfinispanSubsystemXMLWriter());
registerTransformers(subsystem);
}
@Override
public void initialize(ExtensionContext context) {
SubsystemRegistration registration =
context.registerSubsystem(SUBSYSTEM_NAME, ModelVersion.create(1));
registration.registerSubsystemModel(new CliExtCommandsSubsystemResourceDescription());
registration.registerXMLElementWriter(new CliExtCommandsParser());
}
@Override
public void initialize(ExtensionContext context) {
final boolean registerRuntimeOnly = context.isRuntimeOnlyRegistrationValid();
final SubsystemRegistration subsystem =
context.registerSubsystem(
SUBSYSTEM_NAME,
MANAGEMENT_API_MAJOR_VERSION,
MANAGEMENT_API_MINOR_VERSION,
MANAGEMENT_API_MICRO_VERSION);
final ManagementResourceRegistration registration =
subsystem.registerSubsystemModel(SecuritySubsystemRootResourceDefinition.INSTANCE);
registration.registerOperationHandler(
GenericSubsystemDescribeHandler.DEFINITION, GenericSubsystemDescribeHandler.INSTANCE);
final ManagementResourceRegistration securityDomain =
registration.registerSubModel(new SecurityDomainResourceDefinition(registerRuntimeOnly));
final ManagementResourceRegistration jaspi =
securityDomain.registerSubModel(JASPIAuthenticationResourceDefinition.INSTANCE);
jaspi.registerSubModel(LoginModuleStackResourceDefinition.INSTANCE);
securityDomain.registerSubModel(ClassicAuthenticationResourceDefinition.INSTANCE);
securityDomain.registerSubModel(AuthorizationResourceDefinition.INSTANCE);
securityDomain.registerSubModel(MappingResourceDefinition.INSTANCE);
securityDomain.registerSubModel(ACLResourceDefinition.INSTANCE);
securityDomain.registerSubModel(AuditResourceDefinition.INSTANCE);
securityDomain.registerSubModel(IdentityTrustResourceDefinition.INSTANCE);
securityDomain.registerSubModel(JSSEResourceDefinition.INSTANCE);
registration.registerSubModel(VaultResourceDefinition.INSTANCE);
subsystem.registerXMLElementWriter(PARSER);
if (context.isRegisterTransformers()) {
registerTransformers(subsystem);
}
}
@Override
public void initialize(ExtensionContext context) {
log.debug("Initializing Security Extension");
final SubsystemRegistration subsystem = context.registerSubsystem(SUBSYSTEM_NAME);
final ModelNodeRegistration registration =
subsystem.registerSubsystemModel(SecuritySubsystemDescriptions.SUBSYSTEM);
registration.registerOperationHandler(
ADD, SecuritySubsystemAdd.INSTANCE, SecuritySubsystemDescriptions.SUBSYSTEM_ADD, false);
registration.registerOperationHandler(
DESCRIBE,
SecurityDescribeHandler.INSTANCE,
SecuritySubsystemDescriptions.SUBSYSTEM_DESCRIBE,
false);
// security domains
final ModelNodeRegistration securityDomain =
registration.registerSubModel(
PathElement.pathElement(CommonAttributes.SECURITY_DOMAIN),
SecuritySubsystemDescriptions.SECURITY_DOMAIN);
securityDomain.registerOperationHandler(
SecurityDomainAdd.OPERATION_NAME,
SecurityDomainAdd.INSTANCE,
SecuritySubsystemDescriptions.SECURITY_DOMAIN_ADD,
false);
securityDomain.registerOperationHandler(
SecurityDomainRemove.OPERATION_NAME,
SecurityDomainRemove.INSTANCE,
SecuritySubsystemDescriptions.SECURITY_DOMAIN_REMOVE,
false);
subsystem.registerXMLElementWriter(PARSER);
}
@Override
public void initialize(final ExtensionContext context) {
log.debugf("Initializing Connector Extension");
// Register the connector subsystem
final SubsystemRegistration registration = context.registerSubsystem(JCA);
registration.registerXMLElementWriter(NewConnectorSubsystemParser.INSTANCE);
// Connector subsystem description and operation handlers
final ManagementResourceRegistration subsystem = registration.registerSubsystemModel(SUBSYSTEM);
subsystem.registerOperationHandler(ADD, JcaSubsystemAdd.INSTANCE, SUBSYSTEM_ADD_DESC, false);
subsystem.registerOperationHandler(
REMOVE, JcaSubSystemRemove.INSTANCE, SUBSYSTEM_REMOVE_DESC, false);
subsystem.registerOperationHandler(
DESCRIBE,
ConnectorSubsystemDescribeHandler.INSTANCE,
ConnectorSubsystemDescribeHandler.INSTANCE,
false,
OperationEntry.EntryType.PRIVATE);
final ManagementResourceRegistration threadPools =
subsystem.registerSubModel(
PathElement.pathElement(THREAD_POOL), BOUNDED_QUEUE_THREAD_POOL_DESC);
threadPools.registerOperationHandler(
ADD, BoundedQueueThreadPoolAdd.INSTANCE, BoundedQueueThreadPoolAdd.INSTANCE, false);
threadPools.registerOperationHandler(
REMOVE,
BoundedQueueThreadPoolRemove.INSTANCE,
BoundedQueueThreadPoolRemove.INSTANCE,
false);
}
public void initialize(ExtensionContext context) {
final DescriptionProvider subsystemDescription =
new DescriptionProvider() {
public ModelNode getModelDescription(Locale locale) {
return JdrReportDescriptions.getJdrSubsystemDescription(locale);
}
};
SubsystemRegistration subsystemRegistration = context.registerSubsystem(SUBSYSTEM_NAME, 1, 0);
ManagementResourceRegistration root =
subsystemRegistration.registerSubsystemModel(subsystemDescription);
root.registerOperationHandler(
JdrReportSubsystemAdd.OPERATION_NAME,
JdrReportSubsystemAdd.INSTANCE,
JdrReportSubsystemAdd.INSTANCE);
root.registerOperationHandler(
DESCRIBE,
JdrSubsystemDescribeHandler.INSTANCE,
JdrSubsystemDescribeHandler.INSTANCE,
false,
OperationEntry.EntryType.PRIVATE);
root.registerOperationHandler(
JdrReportSubsystemRemove.OPERATION_NAME,
JdrReportSubsystemRemove.INSTANCE,
JdrReportSubsystemRemove.INSTANCE);
if (context.isRuntimeOnlyRegistrationValid()) {
root.registerOperationHandler(
JdrReportRequestHandler.OPERATION_NAME,
JdrReportRequestHandler.INSTANCE,
JdrReportRequestHandler.INSTANCE);
}
subsystemRegistration.registerXMLElementWriter(JdrReportSubsystemParser.INSTANCE);
}
/** {@inheritDoc} */
@Override
public void initialize(ExtensionContext context) {
final SubsystemRegistration subsystem =
context.registerSubsystem(
SUBSYSTEM_NAME,
MANAGEMENT_API_MAJOR_VERSION,
MANAGEMENT_API_MINOR_VERSION,
MANAGEMENT_API_MICRO_VERSION);
// Register the root subsystem resource.
final ManagementResourceRegistration rootResource =
subsystem.registerSubsystemModel(EeSubsystemRootResource.create());
// Mandatory describe operation
rootResource.registerOperationHandler(
GenericSubsystemDescribeHandler.DEFINITION, GenericSubsystemDescribeHandler.INSTANCE);
// register submodels
rootResource.registerSubModel(ContextServiceResourceDefinition.INSTANCE);
rootResource.registerSubModel(ManagedThreadFactoryResourceDefinition.INSTANCE);
rootResource.registerSubModel(ManagedExecutorServiceResourceDefinition.INSTANCE);
rootResource.registerSubModel(ManagedScheduledExecutorServiceResourceDefinition.INSTANCE);
rootResource.registerSubModel(
new DefaultBindingsResourceDefinition(new DefaultBindingsConfigurationProcessor()));
subsystem.registerXMLElementWriter(EESubsystemXmlPersister.INSTANCE);
if (context.isRegisterTransformers()) {
registerTransformers(subsystem);
}
}
/** {@inheritDoc} */
@Override
public void initialize(final ExtensionContext context) {
ROOT_LOGGER.debug("Activating Keycloak Extension");
final SubsystemRegistration subsystem =
context.registerSubsystem(SUBSYSTEM_NAME, MGMT_API_VERSION_MAJOR, MGMT_API_VERSION_MINOR);
subsystem.registerSubsystemModel(KEYCLOAK_SUBSYSTEM_RESOURCE);
subsystem.registerXMLElementWriter(PARSER);
}
protected ManagementResourceRegistration initializeSubsystem(
final SubsystemRegistration registration) {
// Common subsystem tasks
final ResourceDefinition def = createResourceDefinition(SUBSYSTEM_PATH);
registration.registerXMLElementWriter(getParser());
final ManagementResourceRegistration reg = registration.registerSubsystemModel(def);
reg.registerReadWriteAttribute(
TEST_ATTRIBUTE, null, new BasicAttributeWriteHandler(TEST_ATTRIBUTE));
return reg;
}
@Override
public void initialize(ExtensionContext context) {
final SubsystemRegistration subsystem = context.registerSubsystem(SUBSYSTEM_NAME);
final ModelNodeRegistration registration =
subsystem.registerSubsystemModel(OSGiSubsystemProviders.SUBSYSTEM);
registration.registerOperationHandler(
ADD, OSGiSubsystemAdd.INSTANCE, OSGiSubsystemProviders.SUBSYSTEM_ADD, false);
registration.registerOperationHandler(
DESCRIBE,
OSGiSubsystemDescribeHandler.INSTANCE,
OSGiSubsystemDescribeHandler.INSTANCE,
false);
subsystem.registerXMLElementWriter(PARSER);
}
@Override
public void initialize(ExtensionContext context) {
final SubsystemRegistration subsystem = context.registerSubsystem(SUBSYSTEM_NAME, 1, 0);
final ManagementResourceRegistration registration =
subsystem.registerSubsystemModel(SubsystemDefinition.INSTANCE);
registration.registerOperationHandler(
DESCRIBE,
GenericSubsystemDescribeHandler.INSTANCE,
GenericSubsystemDescribeHandler.INSTANCE,
false,
OperationEntry.EntryType.PRIVATE);
subsystem.registerXMLElementWriter(parser);
}
@Override
public void initialize(final ExtensionContext context) {
final SubsystemRegistration subsystem =
context.registerSubsystem(
Constants.SUBSYSTEM_NAME,
MANAGEMENT_API_MAJOR_VERSION,
MANAGEMENT_API_MINOR_VERSION,
MANAGEMENT_API_MICRO_VERSION);
final ManagementResourceRegistration registration =
subsystem.registerSubsystemModel(SecurityManagerRootDefinition.INSTANCE);
registration.registerOperationHandler(
GenericSubsystemDescribeHandler.DEFINITION,
GenericSubsystemDescribeHandler.INSTANCE,
false);
subsystem.registerXMLElementWriter(SecurityManagerSubsystemParser.INSTANCE);
}
/** {@inheritDoc} */
@Override
public void initialize(ExtensionContext context) {
final SubsystemRegistration subsystem =
context.registerSubsystem(SUBSYSTEM_NAME, CURRENT_MODEL_VERSION);
// Register the root subsystem resource.
final ManagementResourceRegistration rootResource =
subsystem.registerSubsystemModel(
new JSR77ManagementRootResource(
context.getProcessType() == ProcessType.APPLICATION_CLIENT));
// Mandatory describe operation
rootResource.registerOperationHandler(
GenericSubsystemDescribeHandler.DEFINITION, GenericSubsystemDescribeHandler.INSTANCE);
subsystem.registerXMLElementWriter(parser);
}
@Override
public void initialize(ExtensionContext context) {
// Register the remoting subsystem
final SubsystemRegistration registration =
context.registerSubsystem(
SUBSYSTEM_NAME,
MANAGEMENT_API_MAJOR_VERSION,
MANAGEMENT_API_MINOR_VERSION,
MANAGEMENT_API_MICRO_VERSION);
registration.registerXMLElementWriter(RemotingSubsystemXMLPersister.INSTANCE);
final ManagementResourceRegistration subsystem =
registration.registerSubsystemModel(
new RemotingSubsystemRootResource(context.getProcessType()));
subsystem.registerOperationHandler(
GenericSubsystemDescribeHandler.DEFINITION, GenericSubsystemDescribeHandler.INSTANCE);
final ManagementResourceRegistration connector =
subsystem.registerSubModel(ConnectorResource.INSTANCE);
connector.registerSubModel(PropertyResource.INSTANCE_CONNECTOR);
final ManagementResourceRegistration sasl = connector.registerSubModel(SaslResource.INSTANCE);
sasl.registerSubModel(SaslPolicyResource.INSTANCE);
sasl.registerSubModel(PropertyResource.INSTANCE_CONNECTOR);
final ManagementResourceRegistration httpConnector =
subsystem.registerSubModel(HttpConnectorResource.INSTANCE);
httpConnector.registerSubModel(PropertyResource.INSTANCE_HTTP_CONNECTOR);
final ManagementResourceRegistration httpSasl =
httpConnector.registerSubModel(SaslResource.INSTANCE);
httpSasl.registerSubModel(SaslPolicyResource.INSTANCE);
httpSasl.registerSubModel(PropertyResource.INSTANCE_HTTP_CONNECTOR);
// remote outbound connection
subsystem.registerSubModel(RemoteOutboundConnectionResourceDefinition.INSTANCE);
// local outbound connection
subsystem.registerSubModel(LocalOutboundConnectionResourceDefinition.INSTANCE);
// (generic) outbound connection
subsystem.registerSubModel(GenericOutboundConnectionResourceDefinition.INSTANCE);
if (context.isRegisterTransformers()) {
registerTransformers_1_1(registration);
registerTransformers_1_2(registration);
registerTransformers_1_3(registration);
}
}
@Override
public void initialize(ExtensionContext context) {
final SubsystemRegistration subsystem =
context.registerSubsystem(SUBSYSTEM_NAME, CURRENT_MODEL_VERSION);
final ManagementResourceRegistration registration =
subsystem.registerSubsystemModel(UndertowRootDefinition.INSTANCE);
registration.registerOperationHandler(
GenericSubsystemDescribeHandler.DEFINITION,
GenericSubsystemDescribeHandler.INSTANCE,
false);
final ManagementResourceRegistration deployments =
subsystem.registerDeploymentModel(DeploymentDefinition.INSTANCE);
deployments.registerSubModel(DeploymentServletDefinition.INSTANCE);
subsystem.registerXMLElementWriter(UndertowSubsystemParser_3_0.INSTANCE);
}
@Override
public void initialize(ExtensionContext context) {
final SubsystemRegistration subsystem = context.registerSubsystem(SUBSYSTEM_NAME, 1, 0, 0);
final ManagementResourceRegistration registration =
subsystem.registerSubsystemModel(DependencySubsystemProviders.SUBSYSTEM);
// We always need to add an 'add' operation
registration.registerOperationHandler(
ADD, DependencySubsystemAdd.INSTANCE, DependencySubsystemProviders.SUBSYSTEM_ADD, false);
// We always need to add a 'describe' operation
registration.registerOperationHandler(
DESCRIBE,
SubsystemDescribeHandler.INSTANCE,
SubsystemDescribeHandler.INSTANCE,
false,
OperationEntry.EntryType.PRIVATE);
subsystem.registerXMLElementWriter(parser);
}
public void initialize(ExtensionContext context) {
final SubsystemRegistration subsystemRegistration =
context.registerSubsystem(SUBSYSTEM_NAME, CURRENT_MODEL_VERSION);
subsystemRegistration.registerXMLElementWriter(MessagingSubsystemParser_1_0.INSTANCE);
boolean registerRuntimeOnly = context.isRuntimeOnlyRegistrationValid();
// Root resource
final ManagementResourceRegistration subsystem =
subsystemRegistration.registerSubsystemModel(
MessagingSubsystemRootResourceDefinition.INSTANCE);
subsystem.registerOperationHandler(
GenericSubsystemDescribeHandler.DEFINITION, GenericSubsystemDescribeHandler.INSTANCE);
// ActiveMQ Servers
final ManagementResourceRegistration server =
subsystem.registerSubModel(new ServerDefinition(registerRuntimeOnly));
for (PathDefinition path :
new PathDefinition[] {
PathDefinition.JOURNAL_INSTANCE,
PathDefinition.BINDINGS_INSTANCE,
PathDefinition.LARGE_MESSAGES_INSTANCE,
PathDefinition.PAGING_INSTANCE
}) {
ManagementResourceRegistration pathRegistry = server.registerSubModel(path);
PathDefinition.registerResolveOperationHandler(context, pathRegistry);
}
subsystem.registerSubModel(JMSBridgeDefinition.INSTANCE);
if (registerRuntimeOnly) {
final ManagementResourceRegistration deployment =
subsystemRegistration.registerDeploymentModel(
new SimpleResourceDefinition(
SUBSYSTEM_PATH, getResourceDescriptionResolver("deployed")));
final ManagementResourceRegistration deployedServer =
deployment.registerSubModel(
new SimpleResourceDefinition(SERVER_PATH, getResourceDescriptionResolver(SERVER)));
deployedServer.registerSubModel(JMSQueueDefinition.DEPLOYMENT_INSTANCE);
deployedServer.registerSubModel(JMSTopicDefinition.DEPLOYMENT_INSTANCE);
deployedServer.registerSubModel(PooledConnectionFactoryDefinition.DEPLOYMENT_INSTANCE);
}
}
/** {@inheritDoc} */
@Override
public void initialize(final ExtensionContext context) {
JSFLogger.ROOT_LOGGER.debug("Activating JSF(Mojarra) Extension");
final SubsystemRegistration subsystem =
context.registerSubsystem(
SUBSYSTEM_NAME,
MANAGEMENT_API_MAJOR_VERSION,
MANAGEMENT_API_MINOR_VERSION,
MANAGEMENT_API_MICRO_VERSION);
final ManagementResourceRegistration registration =
subsystem.registerSubsystemModel(JSF_SUBSYSTEM_RESOURCE);
registration.registerOperationHandler(
DESCRIBE,
GenericSubsystemDescribeHandler.INSTANCE,
GenericSubsystemDescribeHandler.INSTANCE,
false,
OperationEntry.EntryType.PRIVATE);
subsystem.registerXMLElementWriter(PARSER);
}
@Override
public void initialize(ExtensionContext context) {
bootstrap();
log.info("Initializing HA-Singleton Subsystem");
final SubsystemRegistration registration = context.registerSubsystem(SUBSYSTEM_NAME, 1, 0);
final ManagementResourceRegistration subsystem =
registration.registerSubsystemModel(HASingletonSubsystemProviders.SUBSYSTEM);
subsystem.registerOperationHandler(
ADD,
HASingletonSubsystemAdd.ADD_INSTANCE,
HASingletonSubsystemProviders.SUBSYSTEM_ADD,
false);
subsystem.registerOperationHandler(
DESCRIBE,
GenericSubsystemDescribeHandler.INSTANCE,
GenericSubsystemDescribeHandler.INSTANCE,
false,
OperationEntry.EntryType.PRIVATE);
registration.registerXMLElementWriter(HASingletonSubsystemParser.getInstance());
}
public void initialize(ExtensionContext context) {
log.debug("Initializing XTS Extension");
final SubsystemRegistration subsystem = context.registerSubsystem(SUBSYSTEM_NAME);
final ManagementResourceRegistration registration =
subsystem.registerSubsystemModel(XTSSubsystemProviders.SUBSYSTEM);
registration.registerOperationHandler(
ModelDescriptionConstants.ADD,
XTSSubsystemAdd.INSTANCE,
XTSSubsystemProviders.SUBSYSTEM_ADD,
false);
registration.registerOperationHandler(
ModelDescriptionConstants.REMOVE,
XTSSubsystemRemove.INSTANCE,
XTSSubsystemProviders.SUBSYSTEM_REMOVE,
false);
registration.registerOperationHandler(
DESCRIBE,
GenericSubsystemDescribeHandler.INSTANCE,
GenericSubsystemDescribeHandler.INSTANCE,
false,
OperationEntry.EntryType.PRIVATE);
subsystem.registerXMLElementWriter(parser);
}
/**
* Register the transformers for transforming from 1.4.0 to 1.3.0 management api versions, in
* which: - attributes INDEXING_PROPERTIES, SEGMENTS were added in 1.4 - attribute VIRTUAL_NODES
* was deprecated in 1.4 - expression support was added to most attributes in 1.4, except for
* CLUSTER, DEFAULT_CACHE and MODE for which it was already enabled in 1.3
*
* <p>Chaining of transformers is used in cases where two transformers are required for the same
* operation.
*
* @param subsystem the subsystems registration
*/
private static void registerTransformers(final SubsystemRegistration subsystem) {
// define the resource and operation transformers
final InfinispanOperationTransformer_1_3 removeSelectedCacheAttributes =
new InfinispanOperationTransformer_1_3();
final RejectExpressionValuesTransformer cacheContainerReject =
new RejectExpressionValuesTransformer(
InfinispanRejectedExpressions_1_3.REJECT_CONTAINER_ATTRIBUTES);
final RejectExpressionValuesTransformer transportReject =
new RejectExpressionValuesTransformer(
InfinispanRejectedExpressions_1_3.REJECT_TRANSPORT_ATTRIBUTES);
final RejectExpressionValuesTransformer cacheReject =
new RejectExpressionValuesTransformer(
InfinispanRejectedExpressions_1_3.REJECT_CACHE_ATTRIBUTES);
final ChainedOperationTransformer chained =
new ChainedOperationTransformer(removeSelectedCacheAttributes, cacheReject);
// Register the model transformers
TransformersSubRegistration registration =
subsystem.registerModelTransformers(
ModelVersion.create(1, 3), new InfinispanSubsystemTransformer_1_3());
TransformersSubRegistration containerRegistration =
registration.registerSubResource(
CacheContainerResource.CONTAINER_PATH, (OperationTransformer) cacheContainerReject);
containerRegistration.registerSubResource(
TransportResource.TRANSPORT_PATH, (OperationTransformer) transportReject);
PathElement[] cachePaths = {
LocalCacheResource.LOCAL_CACHE_PATH,
InvalidationCacheResource.INVALIDATION_CACHE_PATH,
ReplicatedCacheResource.REPLICATED_CACHE_PATH,
DistributedCacheResource.DISTRIBUTED_CACHE_PATH
};
for (int i = 0; i < cachePaths.length; i++) {
// register chained operation transformers for cache ADD operations where we need to remove
// and reject
TransformersSubRegistration cacheRegistration =
containerRegistration.registerSubResource(cachePaths[i], (OperationTransformer) chained);
registerCacheChildrenTransformers(cacheRegistration);
}
}
@Override
public void initialize(final ExtensionContext context) {
log.debugf("Initializing Threading Extension");
// Register the remoting subsystem
final SubsystemRegistration registration = context.registerSubsystem(THREADS);
registration.registerXMLElementWriter(NewThreadsSubsystemParser.INSTANCE);
// Remoting subsystem description and operation handlers
final ModelNodeRegistration subsystem = registration.registerSubsystemModel(SUBSYSTEM_PROVIDER);
subsystem.registerOperationHandler(
ADD, ThreadsSubsystemAdd.INSTANCE, ThreadsSubsystemAdd.INSTANCE, false);
subsystem.registerOperationHandler(
DESCRIBE,
ThreadsSubsystemDescribeHandler.INSTANCE,
ThreadsSubsystemDescribeHandler.INSTANCE,
false,
OperationEntry.EntryType.PRIVATE);
final ModelNodeRegistration threadFactories =
subsystem.registerSubModel(PathElement.pathElement(THREAD_FACTORY), THREAD_FACTORY_DESC);
threadFactories.registerOperationHandler(
ADD, ThreadFactoryAdd.INSTANCE, ThreadFactoryAdd.INSTANCE, false);
threadFactories.registerOperationHandler(
REMOVE, ThreadFactoryRemove.INSTANCE, ThreadFactoryRemove.INSTANCE, false);
threadFactories.registerReadWriteAttribute(
THREAD_NAME_PATTERN,
null,
ThreadFactoryThreadNamePatternUpdate.INSTANCE,
Storage.CONFIGURATION);
threadFactories.registerReadWriteAttribute(
GROUP_NAME, null, ThreadFactoryGroupNameUpdate.INSTANCE, Storage.CONFIGURATION);
threadFactories.registerReadWriteAttribute(
PRIORITY, null, ThreadFactoryPriorityUpdate.INSTANCE, Storage.CONFIGURATION);
final ModelNodeRegistration boundedQueueThreadPools =
subsystem.registerSubModel(
PathElement.pathElement(BOUNDED_QUEUE_THREAD_POOL), BOUNDED_QUEUE_THREAD_POOL_DESC);
boundedQueueThreadPools.registerOperationHandler(
ADD, BoundedQueueThreadPoolAdd.INSTANCE, BoundedQueueThreadPoolAdd.INSTANCE, false);
boundedQueueThreadPools.registerOperationHandler(
REMOVE,
BoundedQueueThreadPoolRemove.INSTANCE,
BoundedQueueThreadPoolRemove.INSTANCE,
false);
final ModelNodeRegistration unboundedQueueThreadPools =
subsystem.registerSubModel(
PathElement.pathElement(UNBOUNDED_QUEUE_THREAD_POOL), UNBOUNDED_QUEUE_THREAD_POOL_DESC);
unboundedQueueThreadPools.registerOperationHandler(
ADD, UnboundedQueueThreadPoolAdd.INSTANCE, UnboundedQueueThreadPoolAdd.INSTANCE, false);
unboundedQueueThreadPools.registerOperationHandler(
REMOVE,
UnboundedQueueThreadPoolRemove.INSTANCE,
UnboundedQueueThreadPoolRemove.INSTANCE,
false);
final ModelNodeRegistration queuelessThreadPools =
subsystem.registerSubModel(
PathElement.pathElement(QUEUELESS_THREAD_POOL), QUEUELESS_THREAD_POOL_DESC);
queuelessThreadPools.registerOperationHandler(
ADD, QueuelessThreadPoolAdd.INSTANCE, QueuelessThreadPoolAdd.INSTANCE, false);
queuelessThreadPools.registerOperationHandler(
REMOVE, QueuelessThreadPoolRemove.INSTANCE, QueuelessThreadPoolRemove.INSTANCE, false);
final ModelNodeRegistration scheduledThreadPools =
subsystem.registerSubModel(
PathElement.pathElement(SCHEDULED_THREAD_POOL), SCHEDULED_THREAD_POOL_DESC);
scheduledThreadPools.registerOperationHandler(
ADD, ScheduledThreadPoolAdd.INSTANCE, ScheduledThreadPoolAdd.INSTANCE, false);
scheduledThreadPools.registerOperationHandler(
REMOVE, ScheduledThreadPoolRemove.INSTANCE, ScheduledThreadPoolRemove.INSTANCE, false);
}
/**
* {@inheritDoc}
*
* @see org.jboss.as.controller.Extension#initialize(org.jboss.as.controller.ExtensionContext)
*/
@Override
public void initialize(ExtensionContext context) {
SubsystemRegistration subsystem =
context.registerSubsystem(
SUBSYSTEM_NAME,
Namespace.CURRENT.getMajorVersion(),
Namespace.CURRENT.getMinorVersion());
subsystem.registerXMLElementWriter(Namespace.CURRENT.getWriter());
ManagementResourceRegistration registration =
subsystem.registerSubsystemModel(InfinispanSubsystemProviders.SUBSYSTEM);
registration.registerOperationHandler(
ADD, InfinispanSubsystemAdd.INSTANCE, InfinispanSubsystemProviders.SUBSYSTEM_ADD, false);
registration.registerOperationHandler(
DESCRIBE,
InfinispanSubsystemDescribe.INSTANCE,
InfinispanSubsystemProviders.SUBSYSTEM_DESCRIBE,
false,
EntryType.PRIVATE);
registration.registerOperationHandler(
REMOVE,
ReloadRequiredRemoveStepHandler.INSTANCE,
InfinispanSubsystemProviders.SUBSYSTEM_REMOVE,
false);
ManagementResourceRegistration container =
registration.registerSubModel(containerPath, InfinispanSubsystemProviders.CACHE_CONTAINER);
container.registerOperationHandler(
ADD, CacheContainerAdd.INSTANCE, InfinispanSubsystemProviders.CACHE_CONTAINER_ADD, false);
container.registerOperationHandler(
REMOVE,
CacheContainerRemove.INSTANCE,
InfinispanSubsystemProviders.CACHE_CONTAINER_REMOVE,
false);
container.registerOperationHandler(
"add-alias", AddAliasCommand.INSTANCE, InfinispanSubsystemProviders.ADD_ALIAS, false);
container.registerOperationHandler(
"remove-alias",
RemoveAliasCommand.INSTANCE,
InfinispanSubsystemProviders.REMOVE_ALIAS,
false);
CacheContainerWriteAttributeHandler.INSTANCE.registerAttributes(container);
// add /subsystem=infinispan/cache-container=*/singleton=transport:write-attribute
final ManagementResourceRegistration transport =
container.registerSubModel(transportPath, InfinispanSubsystemProviders.TRANSPORT);
transport.registerOperationHandler(
ADD, TransportAdd.INSTANCE, InfinispanSubsystemProviders.TRANSPORT_ADD, false);
transport.registerOperationHandler(
REMOVE, TransportRemove.INSTANCE, InfinispanSubsystemProviders.TRANSPORT_REMOVE, false);
TransportWriteAttributeHandler.INSTANCE.registerAttributes(transport);
// add /subsystem=infinispan/cache-container=*/local-cache=*
ManagementResourceRegistration local =
container.registerSubModel(localCachePath, InfinispanSubsystemProviders.LOCAL_CACHE);
local.registerOperationHandler(
ADD, LocalCacheAdd.INSTANCE, InfinispanSubsystemProviders.LOCAL_CACHE_ADD, false);
local.registerOperationHandler(
REMOVE, CacheRemove.INSTANCE, InfinispanSubsystemProviders.CACHE_REMOVE, false);
registerCommonCacheAttributeHandlers(local);
// add /subsystem=infinispan/cache-container=*/invalidation-cache=*
ManagementResourceRegistration invalidation =
container.registerSubModel(
invalidationCachePath, InfinispanSubsystemProviders.INVALIDATION_CACHE);
invalidation.registerOperationHandler(
ADD,
InvalidationCacheAdd.INSTANCE,
InfinispanSubsystemProviders.INVALIDATION_CACHE_ADD,
false);
invalidation.registerOperationHandler(
REMOVE, CacheRemove.INSTANCE, InfinispanSubsystemProviders.CACHE_REMOVE, false);
registerCommonCacheAttributeHandlers(invalidation);
// add /subsystem=infinispan/cache-container=*/replicated-cache=*
ManagementResourceRegistration replicated =
container.registerSubModel(
replicatedCachePath, InfinispanSubsystemProviders.REPLICATED_CACHE);
replicated.registerOperationHandler(
ADD, ReplicatedCacheAdd.INSTANCE, InfinispanSubsystemProviders.REPLICATED_CACHE_ADD, false);
replicated.registerOperationHandler(
REMOVE, CacheRemove.INSTANCE, InfinispanSubsystemProviders.CACHE_REMOVE, false);
registerCommonCacheAttributeHandlers(replicated);
// add /subsystem=infinispan/cache-container=*/distributed-cache=*
ManagementResourceRegistration distributed =
container.registerSubModel(
distributedCachePath, InfinispanSubsystemProviders.DISTRIBUTED_CACHE);
distributed.registerOperationHandler(
ADD,
DistributedCacheAdd.INSTANCE,
InfinispanSubsystemProviders.DISTRIBUTED_CACHE_ADD,
false);
distributed.registerOperationHandler(
REMOVE, CacheRemove.INSTANCE, InfinispanSubsystemProviders.CACHE_REMOVE, false);
registerCommonCacheAttributeHandlers(distributed);
}
@Override
public void initialize(final ExtensionContext context) {
SUBSYSTEM_RA_LOGGER.debugf("Initializing ResourceAdapters Extension");
// Register the remoting subsystem
final SubsystemRegistration registration = context.registerSubsystem(SUBSYSTEM_NAME);
ReloadRequiredWriteAttributeHandler reloadRequiredWriteAttributeHandler =
new ReloadRequiredWriteAttributeHandler();
registration.registerXMLElementWriter(ResourceAdapterSubsystemParser.INSTANCE);
// Remoting subsystem description and operation handlers
final ManagementResourceRegistration subsystem = registration.registerSubsystemModel(SUBSYSTEM);
subsystem.registerOperationHandler(
ADD, ResourceAdaptersSubSystemAdd.INSTANCE, SUBSYSTEM_ADD_DESC, false);
subsystem.registerOperationHandler(
DESCRIBE,
GenericSubsystemDescribeHandler.INSTANCE,
GenericSubsystemDescribeHandler.INSTANCE,
false,
OperationEntry.EntryType.PRIVATE);
final ManagementResourceRegistration resourceadapter =
subsystem.registerSubModel(
PathElement.pathElement(RESOURCEADAPTER_NAME), RESOURCEADAPTER_DESC);
resourceadapter.registerOperationHandler(ADD, RaAdd.INSTANCE, ADD_RESOURCEADAPTER_DESC, false);
resourceadapter.registerOperationHandler(
REMOVE, RaRemove.INSTANCE, REMOVE_RESOURCEADAPTER_DESC, false);
for (final String attribute : ResourceAdaptersSubsystemProviders.RESOURCEADAPTER_ATTRIBUTE) {
resourceadapter.registerReadWriteAttribute(
attribute, null, reloadRequiredWriteAttributeHandler, Storage.CONFIGURATION);
}
final ManagementResourceRegistration configAdapter =
resourceadapter.registerSubModel(
PathElement.pathElement(CONFIG_PROPERTIES.getName()), CONFIG_PROPERTIES_DESC);
configAdapter.registerOperationHandler(
ADD, ConfigPropertyAdd.INSTANCE, ADD_CONFIG_PROPERTIES_DESC, false);
configAdapter.registerOperationHandler(
REMOVE, ReloadRequiredRemoveStepHandler.INSTANCE, REMOVE_CONFIG_PROPERTIES_DESC, false);
final ManagementResourceRegistration connectionDefinition =
resourceadapter.registerSubModel(
PathElement.pathElement(CONNECTIONDEFINITIONS_NAME), CONNECTION_DEFINITION_DESC);
connectionDefinition.registerOperationHandler(
ADD, ConnectionDefinitionAdd.INSTANCE, ADD_CONNECTION_DEFINITION_DESC, false);
connectionDefinition.registerOperationHandler(
REMOVE, ReloadRequiredRemoveStepHandler.INSTANCE, REMOVE_CONNECTION_DEFINITION_DESC, false);
final ManagementResourceRegistration configCF =
connectionDefinition.registerSubModel(
PathElement.pathElement(CONFIG_PROPERTIES.getName()), CONFIG_PROPERTIES_DESC);
configCF.registerOperationHandler(
ADD, CDConfigPropertyAdd.INSTANCE, ADD_CONFIG_PROPERTIES_DESC, false);
configCF.registerOperationHandler(
REMOVE, ReloadRequiredRemoveStepHandler.INSTANCE, REMOVE_CONFIG_PROPERTIES_DESC, false);
for (final SimpleAttributeDefinition attribute :
ResourceAdaptersSubsystemProviders.CONNECTIONDEFINITIONS_NODEATTRIBUTE) {
connectionDefinition.registerReadWriteAttribute(
attribute.getName(), null, reloadRequiredWriteAttributeHandler, Storage.CONFIGURATION);
}
final ManagementResourceRegistration adminObject =
resourceadapter.registerSubModel(
PathElement.pathElement(ADMIN_OBJECTS_NAME), ADMIN_OBJECT_DESC);
adminObject.registerOperationHandler(
ADD, AdminObjectAdd.INSTANCE, ADD_ADMIN_OBJECT_DESC, false);
adminObject.registerOperationHandler(
REMOVE, ReloadRequiredRemoveStepHandler.INSTANCE, REMOVE_ADMIN_OBJECT_DESC, false);
final ManagementResourceRegistration configAO =
adminObject.registerSubModel(
PathElement.pathElement(CONFIG_PROPERTIES.getName()), CONFIG_PROPERTIES_DESC);
configAO.registerOperationHandler(
ADD, AOConfigPropertyAdd.INSTANCE, ADD_CONFIG_PROPERTIES_DESC, false);
configAO.registerOperationHandler(
REMOVE, ReloadRequiredRemoveStepHandler.INSTANCE, REMOVE_CONFIG_PROPERTIES_DESC, false);
for (final SimpleAttributeDefinition attribute :
ResourceAdaptersSubsystemProviders.ADMIN_OBJECTS_NODEATTRIBUTE) {
adminObject.registerReadWriteAttribute(
attribute.getName(), null, reloadRequiredWriteAttributeHandler, Storage.CONFIGURATION);
}
resourceadapter.registerOperationHandler(
"flush-idle-connection-in-pool",
PoolOperations.FlushIdleConnectionInPool.RA_INSTANCE,
FLUSH_IDLE_CONNECTION_DESC,
false);
resourceadapter.registerOperationHandler(
"flush-all-connection-in-pool",
PoolOperations.FlushAllConnectionInPool.RA_INSTANCE,
FLUSH_ALL_CONNECTION_DESC,
false);
resourceadapter.registerOperationHandler(
"test-connection-in-pool",
PoolOperations.TestConnectionInPool.RA_INSTANCE,
TEST_CONNECTION_DESC,
false);
for (final String attributeName : PoolMetrics.ATTRIBUTES) {
resourceadapter.registerMetric(attributeName, PoolMetrics.RaPoolMetricsHandler.INSTANCE);
}
}
/** {@inheritDoc} */
@Override
public void initialize(ExtensionContext context) {
ROOT_LOGGER.debug("Initializing Deployment Scanner Extension");
final SubsystemRegistration subsystem =
context.registerSubsystem(CommonAttributes.DEPLOYMENT_SCANNER);
subsystem.registerXMLElementWriter(parser);
final ManagementResourceRegistration registration = subsystem.registerSubsystemModel(SUBSYSTEM);
registration.registerOperationHandler(
DeploymentScannerSubsystemAdd.OPERATION_NAME,
DeploymentScannerSubsystemAdd.INSTANCE,
DeploymentScannerSubsystemAdd.INSTANCE,
false);
registration.registerOperationHandler(
DeploymentScannerSubsystemRemove.OPERATION_NAME,
DeploymentScannerSubsystemRemove.INSTANCE,
DeploymentScannerSubsystemRemove.INSTANCE,
false);
// Register operation handlers
final ManagementResourceRegistration scanners =
registration.registerSubModel(scannersPath, SCANNER);
scanners.registerOperationHandler(
DeploymentScannerAdd.OPERATION_NAME,
DeploymentScannerAdd.INSTANCE,
DeploymentScannerAdd.INSTANCE,
false);
scanners.registerOperationHandler(
DeploymentScannerRemove.OPERATION_NAME,
DeploymentScannerRemove.INSTANCE,
DeploymentScannerRemove.INSTANCE,
false);
scanners.registerReadWriteAttribute(
Attribute.PATH.getLocalName(),
null,
WritePathAttributeHandler.INSTANCE,
Storage.CONFIGURATION);
scanners.registerReadWriteAttribute(
Attribute.RELATIVE_TO.getLocalName(),
null,
WriteRelativeToAttributeHandler.INSTANCE,
Storage.CONFIGURATION);
scanners.registerReadWriteAttribute(
Attribute.SCAN_ENABLED.getLocalName(),
null,
WriteEnabledAttributeHandler.INSTANCE,
Storage.CONFIGURATION);
scanners.registerReadWriteAttribute(
Attribute.SCAN_INTERVAL.getLocalName(),
null,
WriteScanIntervalAttributeHandler.INSTANCE,
Storage.CONFIGURATION);
scanners.registerReadWriteAttribute(
Attribute.AUTO_DEPLOY_ZIPPED.getLocalName(),
null,
WriteAutoDeployZipAttributeHandler.INSTANCE,
Storage.CONFIGURATION);
scanners.registerReadWriteAttribute(
Attribute.AUTO_DEPLOY_EXPLODED.getLocalName(),
null,
WriteAutoDeployExplodedAttributeHandler.INSTANCE,
Storage.CONFIGURATION);
scanners.registerReadWriteAttribute(
Attribute.DEPLOYMENT_TIMEOUT.getLocalName(),
null,
WriteDeploymentTimeoutAttributeHandler.INSTANCE,
Storage.CONFIGURATION);
}
@Override
public void initialize(ExtensionContext context) {
SubsystemRegistration registration =
context.registerSubsystem(
SUBSYSTEM_NAME, MANAGEMENT_API_MAJOR_VERSION, MANAGEMENT_API_MINOR_VERSION);
final ManagementResourceRegistration nodeRegistration =
registration.registerSubsystemModel(DESCRIPTION);
PersistenceUnitRegistryImpl persistenceUnitRegistry = new PersistenceUnitRegistryImpl();
JPASubSystemAdd subsystemAdd = new JPASubSystemAdd(persistenceUnitRegistry);
nodeRegistration.registerOperationHandler(
JPASubSystemAdd.OPERATION_NAME, subsystemAdd, subsystemAdd, false);
nodeRegistration.registerOperationHandler(
JPASubSystemRemove.OPERATION_NAME,
JPASubSystemRemove.INSTANCE,
JPASubSystemRemove.INSTANCE,
false);
nodeRegistration.registerOperationHandler(
DESCRIBE,
JPADescribeHandler.INSTANCE,
JPADescribeHandler.INSTANCE,
false,
OperationEntry.EntryType.PRIVATE);
nodeRegistration.registerReadWriteAttribute(
CommonAttributes.DEFAULT_DATASOURCE,
null,
JPADefaultDatasourceWriteHandler.INSTANCE,
Storage.CONFIGURATION);
registration.registerXMLElementWriter(parser);
try {
PersistenceProviderLoader.loadDefaultProvider();
} catch (ModuleLoadException e) {
JPA_LOGGER.errorPreloadingDefaultProvider(e);
}
try {
// load the default persistence provider adaptor
PersistenceProviderAdaptor provider =
PersistenceProviderAdaptorLoader.loadPersistenceAdapterModule(
Configuration.ADAPTER_MODULE_DEFAULT);
final ManagementAdaptor managementAdaptor = provider.getManagementAdaptor();
if (managementAdaptor != null && context.isRuntimeOnlyRegistrationValid()) {
DescriptionProvider JPA_SUBSYSTEM =
new DescriptionProvider() {
@Override
public ModelNode getModelDescription(Locale locale) {
ModelNode subsystem = new ModelNode();
subsystem
.get(org.jboss.as.controller.descriptions.ModelDescriptionConstants.DESCRIPTION)
.set("Runtime information about JPA use in the deployment.");
subsystem.get(ATTRIBUTES).setEmptyObject();
subsystem.get("operations"); // placeholder
subsystem
.get(
CHILDREN,
managementAdaptor.getIdentificationLabel(),
org.jboss.as.controller.descriptions.ModelDescriptionConstants.DESCRIPTION)
.set(
"Runtime information about "
+ managementAdaptor.getIdentificationLabel()
+ " use in the deployment.");
subsystem
.get(CHILDREN, managementAdaptor.getIdentificationLabel(), MIN_OCCURS)
.set(0);
return subsystem;
}
};
final ManagementResourceRegistration jpaSubsystemDeployments =
registration.registerDeploymentModel(JPA_SUBSYSTEM);
managementAdaptor.register(jpaSubsystemDeployments, persistenceUnitRegistry);
}
} catch (ModuleLoadException e) {
JPA_LOGGER.errorPreloadingDefaultProviderAdaptor(e);
}
}