@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);
}
@Override
public void registerOperations(ManagementResourceRegistration registration) {
super.registerOperations(registration);
final OperationDefinition SET_ROOT_LOGGER_DEFINITION =
new SimpleOperationDefinition(
ROOT_LOGGER_ADD_OPERATION_NAME, getResourceDescriptionResolver(), ATTRIBUTES);
registration.registerOperationHandler(
SET_ROOT_LOGGER_DEFINITION, RootLoggerResourceDefinition.ADD_ROOT_LOGGER);
registration.registerOperationHandler(
new SimpleOperationDefinition(
ROOT_LOGGER_REMOVE_OPERATION_NAME, getResourceDescriptionResolver()),
LoggerOperations.REMOVE_LOGGER);
registration.registerOperationHandler(
new SimpleOperationDefinition(
ROOT_LOGGER_CHANGE_LEVEL_OPERATION_NAME,
getResourceDescriptionResolver(),
CommonAttributes.LEVEL),
LoggerOperations.CHANGE_LEVEL);
registration.registerOperationHandler(
new SimpleOperationDefinition(
ROOT_LOGGER_ADD_HANDLER_OPERATION_NAME,
getResourceDescriptionResolver(),
CommonAttributes.HANDLER_NAME),
LoggerOperations.ADD_HANDLER);
registration.registerOperationHandler(
new SimpleOperationDefinition(
ROOT_LOGGER_REMOVE_HANDLER_OPERATION_NAME,
getResourceDescriptionResolver(),
CommonAttributes.HANDLER_NAME),
LoggerOperations.REMOVE_HANDLER);
}
@Override
protected void initModel(Resource rootResource, ManagementResourceRegistration registration) {
registration.registerOperationHandler(
CompositeOperationHandler.DEFINITION, CompositeOperationHandler.INSTANCE);
registration.registerOperationHandler(
new SimpleOperationDefinitionBuilder(
MY_OPERATION, new NonResolvingResourceDescriptionResolver())
.setParameters(FAIL_OPERATION)
.setPrivateEntry()
.build(),
new OperationStepHandler() {
@Override
public void execute(OperationContext context, ModelNode operation)
throws OperationFailedException {
Notification notification =
new Notification(
MY_NOTIFICATION_TYPE,
pathAddress(operation.get(OP_ADDR)),
operation.get("param").asString());
context.emit(notification);
boolean failOperation =
FAIL_OPERATION.resolveModelAttribute(context, operation).asBoolean();
if (failOperation) {
throw new OperationFailedException("failed operation");
}
context.stepCompleted();
}
});
}
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);
}
@Override
public void registerOperations(ManagementResourceRegistration resourceRegistration) {
super.registerOperations(resourceRegistration);
resourceRegistration.registerOperationHandler(
GenericSubsystemDescribeHandler.DEFINITION, GenericSubsystemDescribeHandler.INSTANCE);
resourceRegistration.registerOperationHandler(
MigrateJsonOperation.DEFINITION, new MigrateJsonOperation());
}
@Override
public void registerOperations(ManagementResourceRegistration resourceRegistration) {
super.registerOperations(resourceRegistration);
// register add-alias and remove-alias
resourceRegistration.registerOperationHandler(
CacheContainerResourceDefinition.ALIAS_ADD, AddAliasCommand.INSTANCE);
resourceRegistration.registerOperationHandler(
CacheContainerResourceDefinition.ALIAS_REMOVE, RemoveAliasCommand.INSTANCE);
}
@Override
@SuppressWarnings("deprecation")
public void registerOperationHandler(
String operationName,
OperationStepHandler handler,
DescriptionProvider descriptionProvider) {
deployments.registerOperationHandler(operationName, handler, descriptionProvider);
subdeployments.registerOperationHandler(operationName, handler, descriptionProvider);
}
@Override
public void registerOperations(final ManagementResourceRegistration registration) {
super.registerOperations(registration);
registration.registerOperationHandler(LEGACY_ADD_HANDLER, HandlerOperations.ADD_SUBHANDLER);
registration.registerOperationHandler(
LEGACY_REMOVE_HANDLER, HandlerOperations.REMOVE_SUBHANDLER);
registration.registerOperationHandler(ADD_HANDLER, HandlerOperations.ADD_SUBHANDLER);
registration.registerOperationHandler(REMOVE_HANDLER, HandlerOperations.REMOVE_SUBHANDLER);
}
@Override
public void registerOperations(ManagementResourceRegistration resourceRegistration) {
super.registerOperations(resourceRegistration);
resourceRegistration.registerOperationHandler(
GET_PROVIDER_POINTS,
(context, operation) -> {
final ModelNode model = new ModelNode();
NAME.validateAndSet(operation, model);
final String name = NAME.resolveModelAttribute(context, model).asString();
CapabilityId id =
new CapabilityId(
name, CapabilityScope.GLOBAL); // for possible capabilities it is always global
Set<PathAddress> providerPoints = capabilityRegistry.getPossibleProviderPoints(id);
for (PathAddress point : providerPoints) {
context.getResult().add(point.toCLIStyleString());
}
});
resourceRegistration.registerOperationHandler(
GET_CAPABILITY,
(context, operation) -> {
final ModelNode model = new ModelNode();
NAME.validateAndSet(operation, model);
SCOPE.validateAndSet(operation, model);
final String name = NAME.resolveModelAttribute(context, model).asString();
final CapabilityScope scope;
if (model.hasDefined(SCOPE.getName())) {
String scopeName = SCOPE.resolveModelAttribute(context, model).asString();
scope = CapabilityScope.Factory.forName(scopeName);
} else {
scope = CapabilityScope.GLOBAL;
}
CapabilityId id = new CapabilityId(name, scope);
CapabilityRegistration reg = capabilityRegistry.getCapability(id);
if (reg != null) {
ModelNode result = context.getResult();
populateCapabilityRegistration(reg, result);
}
});
resourceRegistration.registerOperationHandler(
SUGGEST_CAPABILITIES,
(context, operation) -> {
final String name = NAME.resolveModelAttribute(context, operation).asString();
PathAddress address =
PathAddress.pathAddress(DEPENDENT_ADDRESS.resolveModelAttribute(context, operation));
CapabilityScope dependentScope =
CapabilityScope.Factory.create(context.getProcessType(), address);
Set<String> capabilities =
capabilityRegistry.getDynamicCapabilityNames(name, dependentScope);
for (String capability : capabilities) {
context.getResult().add(capability);
}
});
}
@Override
public void registerOperations(final ManagementResourceRegistration registration) {
super.registerOperations(registration);
registration.registerOperationHandler(
new SimpleOperationDefinition(
CHANGE_FILE_OPERATION_NAME, getResourceDescriptionResolver(), CommonAttributes.FILE),
HandlerOperations.CHANGE_FILE);
if (resolvePathHandler != null)
registration.registerOperationHandler(
resolvePathHandler.getOperationDefinition(), resolvePathHandler);
}
// override the add operation to provide a custom definition (for the optional PROPERTIES
// parameter to add())
@Override
protected void registerAddOperation(
final ManagementResourceRegistration registration,
final OperationStepHandler handler,
OperationEntry.Flag... flags) {
registration.registerOperationHandler(FILE_STORE_ADD_DEFINITION, handler);
if (resolvePathHandler != null) {
registration.registerOperationHandler(
resolvePathHandler.getOperationDefinition(), resolvePathHandler);
}
}
private static void registerHandlers(
ManagementResourceRegistration registration, boolean serverGroup) {
registration.registerOperationHandler(
getOperationDefinition(serverGroup, StopServersLifecycleHandler.OPERATION_NAME),
StopServersLifecycleHandler.INSTANCE);
registration.registerOperationHandler(
getOperationDefinition(serverGroup, StartServersLifecycleHandler.OPERATION_NAME),
StartServersLifecycleHandler.INSTANCE);
registration.registerOperationHandler(
getOperationDefinition(serverGroup, RestartServersLifecycleHandler.OPERATION_NAME),
RestartServersLifecycleHandler.INSTANCE);
}
static void register(final ManagementResourceRegistration registration, final String path) {
registration.registerOperationHandler(
ADD, PATH_ADD, new MessagingSubsystemProviders.PathAddProvider(path));
registration.registerOperationHandler(
REMOVE, PATH_REMOVE, MessagingSubsystemProviders.PATH_REMOVE);
AttributeDefinition[] attributes = getAttributes(path);
OperationStepHandler attributeHandler = new ReloadRequiredWriteAttributeHandler(attributes);
for (AttributeDefinition attribute : attributes) {
registration.registerReadWriteAttribute(attribute, null, attributeHandler);
}
}
@Override
protected void initModel(
Resource rootResource, ManagementResourceRegistration rootRegistration) {
this.rootRegistration = rootRegistration;
rootResource.getModel().get(SUBSYSTEM);
rootRegistration.registerOperationHandler(
READ_RESOURCE_OPERATION,
GlobalOperationHandlers.READ_RESOURCE,
CommonProviders.READ_RESOURCE_PROVIDER,
true);
rootRegistration.registerOperationHandler(
READ_ATTRIBUTE_OPERATION,
GlobalOperationHandlers.READ_ATTRIBUTE,
CommonProviders.READ_ATTRIBUTE_PROVIDER,
true);
rootRegistration.registerOperationHandler(
READ_RESOURCE_DESCRIPTION_OPERATION,
GlobalOperationHandlers.READ_RESOURCE_DESCRIPTION,
CommonProviders.READ_RESOURCE_DESCRIPTION_PROVIDER,
true);
rootRegistration.registerOperationHandler(
READ_CHILDREN_NAMES_OPERATION,
GlobalOperationHandlers.READ_CHILDREN_NAMES,
CommonProviders.READ_CHILDREN_NAMES_PROVIDER,
true);
rootRegistration.registerOperationHandler(
READ_CHILDREN_TYPES_OPERATION,
GlobalOperationHandlers.READ_CHILDREN_TYPES,
CommonProviders.READ_CHILDREN_TYPES_PROVIDER,
true);
rootRegistration.registerOperationHandler(
READ_CHILDREN_RESOURCES_OPERATION,
GlobalOperationHandlers.READ_CHILDREN_RESOURCES,
CommonProviders.READ_CHILDREN_RESOURCES_PROVIDER,
true);
rootRegistration.registerOperationHandler(
READ_OPERATION_NAMES_OPERATION,
GlobalOperationHandlers.READ_OPERATION_NAMES,
CommonProviders.READ_OPERATION_NAMES_PROVIDER,
true);
rootRegistration.registerOperationHandler(
READ_OPERATION_DESCRIPTION_OPERATION,
GlobalOperationHandlers.READ_OPERATION_DESCRIPTION,
CommonProviders.READ_OPERATION_PROVIDER,
true);
rootRegistration.registerOperationHandler(
WRITE_ATTRIBUTE_OPERATION,
GlobalOperationHandlers.WRITE_ATTRIBUTE,
CommonProviders.WRITE_ATTRIBUTE_PROVIDER,
true);
controllerInitializer.initializeModel(rootResource, rootRegistration);
ExtensionContext context = new ExtensionContextImpl(rootRegistration, null, persister);
additionalInit.initializeExtraSubystemsAndModel(context, rootResource, rootRegistration);
mainExtension.initialize(context);
}
@Override
@SuppressWarnings("deprecation")
public void registerOperationHandler(
String operationName,
OperationStepHandler handler,
DescriptionProvider descriptionProvider,
boolean inherited,
EnumSet<OperationEntry.Flag> flags) {
deployments.registerOperationHandler(
operationName, handler, descriptionProvider, inherited, flags);
subdeployments.registerOperationHandler(
operationName, handler, descriptionProvider, inherited, flags);
}
public void invoke() {
PathElement ijPe =
PathElement.pathElement(Constants.IRONJACAMAR_NAME, Constants.IRONJACAMAR_NAME);
ManagementResourceRegistration ironJacamarChild =
parentRegistration.registerSubModel(
ijPe, ResourceAdaptersSubsystemProviders.IRONJACAMAR_DESC);
PathElement raPath = PathElement.pathElement(RESOURCEADAPTER_NAME);
ManagementResourceRegistration raChild =
ironJacamarChild.registerSubModel(raPath, RESOURCEADAPTER_RO_DESC);
PathElement configPath = PathElement.pathElement(CONFIG_PROPERTIES.getName());
ManagementResourceRegistration configChild =
raChild.registerSubModel(configPath, CONFIG_PROPERTIES_RO_DESC);
PathElement connDefPath = PathElement.pathElement(CONNECTIONDEFINITIONS_NAME);
ManagementResourceRegistration connChild =
raChild.registerSubModel(connDefPath, CONNECTION_DEFINITION_RO_DESC);
PathElement connDefConfigPath = PathElement.pathElement(CONFIG_PROPERTIES.getName());
ManagementResourceRegistration connDefConfigChild =
connChild.registerSubModel(connDefConfigPath, CONFIG_PROPERTIES_RO_DESC);
PathElement adminObjectPath = PathElement.pathElement(ADMIN_OBJECTS_NAME);
ManagementResourceRegistration adminObjectChild =
raChild.registerSubModel(adminObjectPath, ADMIN_OBJECT_RO_DESC);
PathElement adminObjectConfigPath = PathElement.pathElement(CONFIG_PROPERTIES.getName());
ManagementResourceRegistration adminObjectConfigChild =
adminObjectChild.registerSubModel(adminObjectConfigPath, CONFIG_PROPERTIES_RO_DESC);
connChild.registerOperationHandler(
"flush-idle-connection-in-pool",
PoolOperations.FlushIdleConnectionInPool.RA_INSTANCE,
FLUSH_IDLE_CONNECTION_DESC,
false,
RUNTIME_ONLY_FLAG);
connChild.registerOperationHandler(
"flush-all-connection-in-pool",
PoolOperations.FlushAllConnectionInPool.RA_INSTANCE,
FLUSH_ALL_CONNECTION_DESC,
false,
RUNTIME_ONLY_FLAG);
connChild.registerOperationHandler(
"test-connection-in-pool",
PoolOperations.TestConnectionInPool.RA_INSTANCE,
TEST_CONNECTION_DESC,
false,
RUNTIME_ONLY_FLAG);
}
// override the add operation to provide a custom definition (for the optional PROPERTIES
// parameter to add())
@Override
protected void registerAddOperation(
final ManagementResourceRegistration registration,
final OperationStepHandler handler,
OperationEntry.Flag... flags) {
registration.registerOperationHandler(LOADER_ADD_DEFINITION, handler);
}
/** {@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);
}
}
@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);
}
}
/**
* {@inheritDoc} Registers an add operation handler or a remove operation handler if one was
* provided to the constructor.
*/
@Override
public void registerOperations(ManagementResourceRegistration resourceRegistration) {
super.registerOperations(resourceRegistration);
// We always need to add a 'describe' operation for root resource
resourceRegistration.registerOperationHandler(
GenericSubsystemDescribeHandler.DEFINITION, GenericSubsystemDescribeHandler.INSTANCE);
}
@Override
public void registerOperations(ManagementResourceRegistration resourceRegistration) {
super.registerOperations(resourceRegistration);
SimpleOperationDefinitionBuilder builder =
new SimpleOperationDefinitionBuilder(
NamingSubsystemModel.REBIND, getResourceDescriptionResolver())
.addParameter(BINDING_TYPE)
.addParameter(TYPE)
.addParameter(VALUE)
.addParameter(CLASS)
.addParameter(MODULE)
.addParameter(LOOKUP)
.addParameter(ENVIRONMENT);
resourceRegistration.registerOperationHandler(
builder.build(),
new OperationStepHandler() {
@Override
public void execute(OperationContext context, ModelNode operation)
throws OperationFailedException {
context.addStep(
new OperationStepHandler() {
@Override
public void execute(OperationContext context, ModelNode operation)
throws OperationFailedException {
validateResourceModel(operation, false);
Resource resource = context.readResourceForUpdate(PathAddress.EMPTY_ADDRESS);
ModelNode model = resource.getModel();
for (AttributeDefinition attr : ATTRIBUTES) {
attr.validateAndSet(operation, model);
}
context.addStep(
new OperationStepHandler() {
@Override
public void execute(OperationContext context, ModelNode operation)
throws OperationFailedException {
final String name = context.getCurrentAddressValue();
final ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(name);
ServiceController<ManagedReferenceFactory> service =
(ServiceController<ManagedReferenceFactory>)
context
.getServiceRegistry(false)
.getService(bindInfo.getBinderServiceName());
if (service == null) {
context.reloadRequired();
return;
}
NamingBindingAdd.INSTANCE.doRebind(
context, operation, (BinderService) service.getService());
}
},
OperationContext.Stage.RUNTIME);
}
},
OperationContext.Stage.MODEL);
}
});
}
@Override
protected void initModel(Resource rootResource, ManagementResourceRegistration root) {
root.registerOperationHandler("read-resource", ReadResourceHandler.INSTANCE, NULL, true);
root.registerOperationHandler("describe", new DescribeHandler(), NULL, true);
root.registerOperationHandler(
"setup",
new OperationStepHandler() {
@Override
public void execute(OperationContext context, ModelNode operation)
throws OperationFailedException {
final ModelNode model = new ModelNode();
model
.get("host", "A", "server", "one", "subsystem", "web", "connector", "default", "1")
.setEmptyObject();
model
.get("host", "A", "server", "two", "subsystem", "web", "connector", "default", "2")
.setEmptyObject();
model
.get("host", "A", "server", "three", "subsystem", "web", "connector", "other", "3")
.setEmptyObject();
model
.get("host", "B", "server", "one", "subsystem", "web", "connector", "default", "4")
.setEmptyObject();
model
.get("host", "B", "server", "two", "subsystem", "web", "connector", "default", "5")
.setEmptyObject();
model
.get(
"host", "B", "server", "three", "subsystem", "web", "connector", "default", "6")
.setEmptyObject();
createModel(context, model);
context.stepCompleted();
}
},
NULL);
final ManagementResourceRegistration hosts = root.registerSubModel(host, NULL);
final ManagementResourceRegistration servers = hosts.registerSubModel(server, NULL);
final ManagementResourceRegistration subsystems = servers.registerSubModel(subsystem, NULL);
final ManagementResourceRegistration connectors = subsystems.registerSubModel(connector, NULL);
}
static void createPropertyRegistration(final ManagementResourceRegistration parent) {
final ManagementResourceRegistration registration =
parent.registerSubModel(storePropertyPath, InfinispanSubsystemProviders.STORE_PROPERTY);
registration.registerOperationHandler(
ADD,
CacheConfigOperationHandlers.STORE_PROPERTY_ADD,
InfinispanSubsystemProviders.STORE_PROPERTY_ADD);
registration.registerOperationHandler(
REMOVE,
CacheConfigOperationHandlers.REMOVE,
InfinispanSubsystemProviders.STORE_PROPERTY_REMOVE);
registration.registerReadWriteAttribute(
"value",
null,
CacheConfigOperationHandlers.STORE_PROPERTY_ATTR,
EnumSet.of(AttributeAccess.Flag.RESTART_ALL_SERVICES));
}
@Override
public void register(ManagementResourceRegistration registration) {
registration.registerOperationHandler(
new SimpleOperationDefinitionBuilder(
ModelDescriptionConstants.REMOVE, this.descriptor.getDescriptionResolver())
.withFlag(OperationEntry.Flag.RESTART_RESOURCE_SERVICES)
.build(),
this);
}
@Override
public void registerOperations(ManagementResourceRegistration resourceRegistration) {
registerAddOperation(resourceRegistration, addHandler);
OperationDefinition removeDef =
new SimpleOperationDefinitionBuilder(
ModelDescriptionConstants.REMOVE, getResourceDescriptionResolver())
.build();
resourceRegistration.registerOperationHandler(removeDef, removeHandler);
}
@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);
}
@Override
public void registerOperations(final ManagementResourceRegistration rootResourceRegistration) {
final ResourceDescriptionResolver rootResolver = getResourceDescriptionResolver();
// Ops to add and remove the root resource
final DescriptionProvider subsystemAddDescription =
new DefaultResourceAddDescriptionProvider(rootResourceRegistration, rootResolver);
rootResourceRegistration.registerOperationHandler(
ADD,
SipSubsystemAdd.INSTANCE,
subsystemAddDescription,
EnumSet.of(OperationEntry.Flag.RESTART_ALL_SERVICES));
final DescriptionProvider subsystemRemoveDescription =
new DefaultResourceRemoveDescriptionProvider(rootResolver);
rootResourceRegistration.registerOperationHandler(
REMOVE,
ReloadRequiredRemoveStepHandler.INSTANCE,
subsystemRemoveDescription,
EnumSet.of(OperationEntry.Flag.RESTART_ALL_SERVICES));
}
@Override
public void registerOperations(ManagementResourceRegistration resourceRegistration) {
super.registerOperations(resourceRegistration);
resourceRegistration.registerOperationHandler(
ModelDescriptionConstants.DESCRIBE,
GenericSubsystemDescribeHandler.INSTANCE,
GenericSubsystemDescribeHandler.INSTANCE,
false,
OperationEntry.EntryType.PRIVATE);
}
@Test
public void testHandlersOnRootResource() throws Exception {
rootRegistration.registerOperationHandler(
"one", TestHandler.ONE, new TestDescriptionProvider("one"));
rootRegistration.registerOperationHandler(
"two",
TestHandler.TWO,
new TestDescriptionProvider("two"),
false,
OperationEntry.EntryType.PUBLIC,
EnumSet.of(OperationEntry.Flag.READ_ONLY));
OperationStepHandler oneHandler =
rootRegistration.getOperationHandler(PathAddress.EMPTY_ADDRESS, "one");
assertSame(TestHandler.ONE, oneHandler);
OperationStepHandler twoHandler =
rootRegistration.getOperationHandler(PathAddress.EMPTY_ADDRESS, "two");
assertSame(TestHandler.TWO, twoHandler);
}
@Override
public void registerOperations(ManagementResourceRegistration registration) {
registration.registerOperationHandler(
GenericSubsystemDescribeHandler.DEFINITION, GenericSubsystemDescribeHandler.INSTANCE);
ResourceDescriptor descriptor =
new ResourceDescriptor(this.getResourceDescriptionResolver())
.addAttributes(Attribute.class);
ResourceServiceHandler handler = new JGroupsSubsystemServiceHandler();
new AddStepHandler(descriptor, handler).register(registration);
new RemoveStepHandler(descriptor, handler).register(registration);
}
