@Override
public void registerChildren(ManagementResourceRegistration resourceRegistration) {
resourceRegistration.registerSubModel(
LdapCacheResourceDefinition.createByAccessTime(CacheFor.AuthUser));
resourceRegistration.registerSubModel(
LdapCacheResourceDefinition.createBySearchTime(CacheFor.AuthUser));
}
@Override
public void registerChildren(ManagementResourceRegistration resourceRegistration) {
resourceRegistration.registerSubModel(
TlsKeyStore.createTrustStore(auditLogger, pathManager, environmentReader));
resourceRegistration.registerSubModel(
TlsKeyStore.createClientCertStore(auditLogger, pathManager, environmentReader));
}
/** {@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 registerChildren(ManagementResourceRegistration resourceRegistration) {
if (deployed) {
resourceRegistration.registerSubModel(XaDataSourcePropertyDefinition.DEPLOYED_INSTANCE);
} else {
resourceRegistration.registerSubModel(XaDataSourcePropertyDefinition.INSTANCE);
}
}
@SuppressWarnings("deprecation")
@Override
public ManagementResourceRegistration registerSubModel(
PathElement address, DescriptionProvider descriptionProvider) {
ManagementResourceRegistration depl =
deployments.registerSubModel(address, descriptionProvider);
ManagementResourceRegistration subdepl =
subdeployments.registerSubModel(address, descriptionProvider);
return new DeploymentManagementResourceRegistration(depl, subdepl);
}
@Override
public void registerChildren(ManagementResourceRegistration resourceRegistration) {
// child resources
resourceRegistration.registerSubModel(new TransportResourceDefinition());
resourceRegistration.registerSubModel(
new LocalCacheResourceDefinition(this.resolvePathHandler, this.runtimeRegistration));
resourceRegistration.registerSubModel(
new InvalidationCacheResourceDefinition(this.resolvePathHandler, this.runtimeRegistration));
resourceRegistration.registerSubModel(
new ReplicatedCacheResourceDefinition(this.resolvePathHandler, this.runtimeRegistration));
resourceRegistration.registerSubModel(
new DistributedCacheResourceDefinition(this.resolvePathHandler, this.runtimeRegistration));
}
@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);
}
private void testAddWithVaultWriteSensitivity(StandardRole role, boolean success)
throws Exception {
try {
VaultExpressionSensitivityConfig.INSTANCE.setConfiguredRequiresWritePermission(true);
ChildResourceDefinition def = new ChildResourceDefinition(ONE);
def.addAttribute("test");
rootRegistration.registerSubModel(def);
Resource resourceA = Resource.Factory.create();
resourceA.getModel().get("test").set("a");
rootResource.registerChild(ONE_A, resourceA);
ModelNode op = Util.createAddOperation(ONE_B_ADDR);
op.get("test").set("${VAULT::AA::bb::cc}");
op.get(OPERATION_HEADERS, "roles").set(role.toString());
if (success) {
executeForResult(op);
} else {
executeForFailure(op);
}
} finally {
VaultExpressionSensitivityConfig.INSTANCE.setConfiguredRequiresAccessPermission(null);
VaultExpressionSensitivityConfig.INSTANCE.setConfiguredRequiresReadPermission(null);
VaultExpressionSensitivityConfig.INSTANCE.setConfiguredRequiresWritePermission(null);
}
}
@Override
public void registerChildren(ManagementResourceRegistration resourceRegistration) {
super.registerChildren(resourceRegistration);
for (PersistentResourceDefinition child : getChildren()) {
resourceRegistration.registerSubModel(child);
}
}
@Override
public void registerChildren(ManagementResourceRegistration resourceRegistration) {
super.registerChildren(resourceRegistration);
resourceRegistration.registerSubModel(
SystemPropertyResourceDefinition.createForDomainOrHost(Location.DOMAIN));
resourceRegistration.registerSubModel(
new InterfaceDefinition(
InterfaceAddHandler.NAMED_INSTANCE, InterfaceRemoveHandler.INSTANCE, false));
resourceRegistration.registerSubModel(new ProfileResourceDefinition(extensionRegistry));
resourceRegistration.registerSubModel(PathResourceDefinition.createNamed(pathManager));
resourceRegistration.registerSubModel(
DomainDeploymentResourceDescription.createForDomainRoot(
isMaster, contentRepo, fileRepository));
resourceRegistration.registerSubModel(
new DeploymentOverlayDefinition(null, contentRepo, fileRepository));
resourceRegistration.registerSubModel(
new ServerGroupResourceDefinition(contentRepo, fileRepository));
// TODO socket-binding-group currently lives in controller and the child RDs live in domain so
// they currently need passing in from here
resourceRegistration.registerSubModel(
new SocketBindingGroupResourceDefinition(
SocketBindingGroupAddHandler.INSTANCE,
DomainSocketBindingGroupRemoveHandler.INSTANCE,
true,
SocketBindingResourceDefinition.INSTANCE,
RemoteDestinationOutboundSocketBindingResourceDefinition.INSTANCE,
LocalDestinationOutboundSocketBindingResourceDefinition.INSTANCE));
// TODO perhaps all these desriptions and the validator log messages should be moved into
// management-client-content?
resourceRegistration.registerSubModel(
new ManagedDMRContentTypeResourceDefinition(
contentRepo,
ROLLOUT_PLAN,
PathElement.pathElement(MANAGEMENT_CLIENT_CONTENT, ROLLOUT_PLANS),
new RolloutPlanValidator(),
DomainResolver.getResolver(ROLLOUT_PLANS),
DomainResolver.getResolver(ROLLOUT_PLAN)));
// Extensions
resourceRegistration.registerSubModel(
new ExtensionResourceDefinition(extensionRegistry, true, !isMaster));
// Initialize the domain transformers
DomainTransformers.initializeDomainRegistry(extensionRegistry.getTransformerRegistry());
}
@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);
}
@Override
public ManagementResourceRegistration registerDeploymentModel(
ResourceDefinition resourceDefinition) {
assert resourceDefinition != null : "resourceDefinition is null";
final ManagementResourceRegistration deploymentsReg = deploymentsRegistration;
ManagementResourceRegistration base =
deploymentsReg != null ? deploymentsReg : getDummyRegistration();
return base.registerSubModel(resourceDefinition);
}
@Override
public void register(ManagementResourceRegistration parentRegistration) {
ManagementResourceRegistration registration = parentRegistration.registerSubModel(this);
parentRegistration.registerAlias(LEGACY_PATH, new SimpleAliasEntry(registration));
ResourceDescriptor descriptor =
new ResourceDescriptor(this.getResourceDescriptionResolver())
.addAttributes(JDBCStoreResourceDefinition.Attribute.class)
.addAttributes(StoreResourceDefinition.Attribute.class)
.addExtraParameters(DeprecatedAttribute.class)
.addExtraParameters(JDBCStoreResourceDefinition.DeprecatedAttribute.class)
.addCapabilities(Capability.class)
.addRequiredChildren(BinaryTableResourceDefinition.PATH)
.addRequiredSingletonChildren(StoreWriteThroughResourceDefinition.PATH);
ResourceServiceHandler handler =
new SimpleResourceServiceHandler<>(new BinaryKeyedJDBCStoreBuilderFactory());
new AddStepHandler(descriptor, handler) {
@Override
protected void populateModel(OperationContext context, ModelNode operation, Resource resource)
throws OperationFailedException {
translateAddOperation(context, operation);
if (operation.hasDefined(DeprecatedAttribute.TABLE.getDefinition().getName())) {
// Translate deprecated TABLE attribute into separate add table operation
ModelNode addTableOperation =
Util.createAddOperation(
context.getCurrentAddress().append(BinaryTableResourceDefinition.PATH));
ModelNode parameters = operation.get(DeprecatedAttribute.TABLE.getDefinition().getName());
for (Property parameter : parameters.asPropertyList()) {
addTableOperation.get(parameter.getName()).set(parameter.getValue());
}
context.addStep(
addTableOperation,
registration.getOperationHandler(
PathAddress.pathAddress(BinaryTableResourceDefinition.PATH),
ModelDescriptionConstants.ADD),
context.getCurrentStage());
}
super.populateModel(context, operation, resource);
}
}.register(registration);
new RemoveStepHandler(descriptor, handler).register(registration);
registration.registerReadWriteAttribute(
DeprecatedAttribute.TABLE.getDefinition(),
LEGACY_READ_TABLE_HANDLER,
LEGACY_WRITE_TABLE_HANDLER);
new BinaryTableResourceDefinition().register(registration);
super.register(registration);
}
@Override
public ManagementResourceRegistration registerSubsystemModel(
ResourceDefinition resourceDefinition) {
assert resourceDefinition != null : "resourceDefinition is null";
ManagementResourceRegistration profileReg = profileRegistration;
if (profileReg == null) {
// we've been cleared and haven't re-initialized. This would mean a management op is
// registering
// an extension at the same time we are shutting down or reloading. Unlikely.
// Just provide a fake reg to the op (whose work is being discarded anyway) so it can finish
// cleanly.
profileReg = getDummyRegistration();
}
return profileReg.registerSubModel(resourceDefinition);
}
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
public void register(ManagementResourceRegistration parentRegistration) {
ManagementResourceRegistration registration = parentRegistration.registerSubModel(this);
parentRegistration.registerAlias(LEGACY_PATH, new SimpleAliasEntry(registration));
ResourceDescriptor descriptor =
new ResourceDescriptor(this.getResourceDescriptionResolver())
.addAttributes(Attribute.class)
.addAttributes(StoreResourceDefinition.Attribute.class)
.addCapabilities(Capability.class)
.addRequiredSingletonChildren(StoreWriteThroughResourceDefinition.PATH);
ResourceServiceHandler handler =
new SimpleResourceServiceHandler<>(address -> new RemoteStoreBuilder(address.getParent()));
new SimpleResourceRegistration(descriptor, handler).register(registration);
super.register(registration);
}
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 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);
}
private void testAddNoSensitivity(StandardRole role, boolean success) throws Exception {
ChildResourceDefinition def = new ChildResourceDefinition(ONE);
def.addAttribute("test");
rootRegistration.registerSubModel(def);
Resource resourceA = Resource.Factory.create();
resourceA.getModel().get("test").set("a");
rootResource.registerChild(ONE_A, resourceA);
ModelNode op = Util.createAddOperation(ONE_B_ADDR);
op.get("test").set("b");
op.get(OPERATION_HEADERS, "roles").set(role.toString());
if (success) {
executeForResult(op);
} else {
executeForFailure(op);
}
}
@Test
public void testFlagsOnChildResource() throws Exception {
ManagementResourceRegistration child =
rootRegistration.registerSubModel(childElement, new TestDescriptionProvider("child"));
child.registerOperationHandler("one", TestHandler.INSTANCE, new TestDescriptionProvider("one"));
child.registerOperationHandler(
"two",
TestHandler.INSTANCE,
new TestDescriptionProvider("two"),
false,
OperationEntry.EntryType.PUBLIC,
EnumSet.of(OperationEntry.Flag.READ_ONLY));
Set<OperationEntry.Flag> oneFlags = child.getOperationFlags(PathAddress.EMPTY_ADDRESS, "one");
assertNotNull(oneFlags);
assertEquals(0, oneFlags.size());
Set<OperationEntry.Flag> twoFlags = child.getOperationFlags(PathAddress.EMPTY_ADDRESS, "two");
assertNotNull(twoFlags);
assertEquals(1, twoFlags.size());
oneFlags = rootRegistration.getOperationFlags(childAddress, "one");
assertNotNull(oneFlags);
assertEquals(0, oneFlags.size());
twoFlags = rootRegistration.getOperationFlags(childAddress, "two");
assertNotNull(twoFlags);
assertEquals(1, twoFlags.size());
oneFlags = rootRegistration.getOperationFlags(fullChildAddress, "one");
assertNotNull(oneFlags);
assertEquals(0, oneFlags.size());
twoFlags = rootRegistration.getOperationFlags(fullChildAddress, "two");
assertNotNull(twoFlags);
assertEquals(1, twoFlags.size());
}
@Test
public void testHandlersOnChildResource() throws Exception {
ManagementResourceRegistration child =
rootRegistration.registerSubModel(childElement, new TestDescriptionProvider("child"));
child.registerOperationHandler("one", TestHandler.ONE, new TestDescriptionProvider("one"));
child.registerOperationHandler(
"two",
TestHandler.TWO,
new TestDescriptionProvider("two"),
false,
OperationEntry.EntryType.PUBLIC,
EnumSet.of(OperationEntry.Flag.READ_ONLY));
OperationStepHandler oneHandler = child.getOperationHandler(PathAddress.EMPTY_ADDRESS, "one");
assertSame(TestHandler.ONE, oneHandler);
OperationStepHandler twoHandler = child.getOperationHandler(PathAddress.EMPTY_ADDRESS, "two");
assertSame(TestHandler.TWO, twoHandler);
oneHandler = rootRegistration.getOperationHandler(childAddress, "one");
assertSame(TestHandler.ONE, oneHandler);
twoHandler = rootRegistration.getOperationHandler(childAddress, "two");
assertSame(TestHandler.TWO, twoHandler);
oneHandler = rootRegistration.getOperationHandler(fullChildAddress, "one");
assertSame(TestHandler.ONE, oneHandler);
twoHandler = rootRegistration.getOperationHandler(fullChildAddress, "two");
assertSame(TestHandler.TWO, twoHandler);
oneHandler = rootRegistration.getOperationHandler(PathAddress.EMPTY_ADDRESS, "one");
assertNull(oneHandler);
twoHandler = rootRegistration.getOperationHandler(PathAddress.EMPTY_ADDRESS, "two");
assertNull(twoHandler);
}
@Override
public void register(ManagementResourceRegistration parentRegistration) {
ManagementResourceRegistration registration = parentRegistration.registerSubModel(this);
ResourceDescriptor descriptor =
new ResourceDescriptor(this.getResourceDescriptionResolver())
.addAttributes(Attribute.class);
ResourceServiceHandler handler =
new SimpleResourceServiceHandler<>(
address -> new PartitionHandlingBuilder(address.getParent()));
new SimpleResourceRegistration(descriptor, handler).register(registration);
if (this.allowRuntimeOnlyRegistration) {
new OperationHandler<>(
new PartitionHandlingOperationExecutor(), PartitionHandlingOperation.class)
.register(registration);
}
if (this.allowRuntimeOnlyRegistration) {
new MetricHandler<>(new PartitionHandlingMetricExecutor(), PartitionHandlingMetric.class)
.register(registration);
}
}
@SuppressWarnings("deprecation")
@Override
public void register(ManagementResourceRegistration parentRegistration) {
ManagementResourceRegistration registration = parentRegistration.registerSubModel(this);
ResourceDescriptor descriptor =
new ResourceDescriptor(this.getResourceDescriptionResolver())
.addAttributes(Attribute.class)
.addExtraParameters(DeprecatedAttribute.class)
.addCapabilities(Capability.class);
ResourceServiceHandler handler =
new SimpleResourceServiceHandler<>(new ProtocolConfigurationBuilderFactory());
new RestartParentResourceAddStepHandler<>(this.parentBuilderFactory, descriptor, handler)
.register(registration);
new RestartParentResourceRemoveStepHandler<>(this.parentBuilderFactory, descriptor, handler)
.register(registration);
for (DeprecatedAttribute attribute : DeprecatedAttribute.values()) {
registration.registerReadOnlyAttribute(attribute.getDefinition(), null);
}
super.register(registration);
}
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);
}
}
public static void initOperations(
final ManagementResourceRegistration root,
final ContentRepository contentRepository,
final ExtensibleConfigurationPersister extensibleConfigurationPersister,
final ServerEnvironment serverEnvironment,
final ControlledProcessState processState,
final RunningModeControl runningModeControl,
final AbstractVaultReader vaultReader,
final ExtensionRegistry extensionRegistry,
final boolean parallelBoot,
final PathManagerService pathManager) {
// System Properties
root.registerSubModel(
SystemPropertyResourceDefinition.createForStandaloneServer(serverEnvironment));
// vault
root.registerSubModel(new VaultResourceDefinition(vaultReader));
// Central Management
// Start with the base /core-service=management MNR. The Resource for this is added by
// ServerService itself, so there is no add/remove op handlers
ManagementResourceRegistration management =
root.registerSubModel(CoreManagementDefinition.INSTANCE);
management.registerSubModel(SecurityRealmResourceDefinition.INSTANCE);
management.registerSubModel(LdapConnectionResourceDefinition.INSTANCE);
management.registerSubModel(NativeManagementResourceDefinition.INSTANCE);
management.registerSubModel(NativeRemotingManagementResourceDefinition.INSTANCE);
management.registerSubModel(HttpManagementResourceDefinition.INSTANCE);
// Other core services
ManagementResourceRegistration serviceContainer =
root.registerSubModel(
new SimpleResourceDefinition(
PathElement.pathElement(CORE_SERVICE, SERVICE_CONTAINER),
ControllerResolver.getResolver("core", SERVICE_CONTAINER)));
serviceContainer.registerOperationHandler(
DumpServicesHandler.DEFINITION, DumpServicesHandler.INSTANCE);
// Platform MBeans
PlatformMBeanResourceRegistrar.registerPlatformMBeanResources(root);
// Paths
root.registerSubModel(PathResourceDefinition.createSpecified(pathManager));
// Interfaces
ManagementResourceRegistration interfaces =
root.registerSubModel(
new InterfaceDefinition(
SpecifiedInterfaceAddHandler.INSTANCE,
SpecifiedInterfaceRemoveHandler.INSTANCE,
true));
interfaces.registerReadOnlyAttribute(
NetworkInterfaceRuntimeHandler.RESOLVED_ADDRESS, NetworkInterfaceRuntimeHandler.INSTANCE);
interfaces.registerOperationHandler(
SpecifiedInterfaceResolveHandler.DEFINITION, SpecifiedInterfaceResolveHandler.INSTANCE);
// TODO socket-binding-group currently lives in controller and the child RDs live in server so
// they currently need passing in from here
root.registerSubModel(
new SocketBindingGroupResourceDefinition(
BindingGroupAddHandler.INSTANCE,
SocketBindingGroupRemoveHandler.INSTANCE,
false,
SocketBindingResourceDefinition.INSTANCE,
RemoteDestinationOutboundSocketBindingResourceDefinition.INSTANCE,
LocalDestinationOutboundSocketBindingResourceDefinition.INSTANCE));
// Deployments
ManagementResourceRegistration deployments =
root.registerSubModel(
ServerDeploymentResourceDescription.create(contentRepository, vaultReader));
// deployment overlays
root.registerSubModel(
new DeploymentOverlayDefinition(DeploymentOverlayPriority.SERVER, contentRepository, null));
// The sub-deployments registry
deployments.registerSubModel(
new SimpleResourceDefinition(
PathElement.pathElement(SUBDEPLOYMENT), DeploymentAttributes.DEPLOYMENT_RESOLVER));
// Extensions
root.registerSubModel(new ExtensionResourceDefinition(extensionRegistry, parallelBoot, false));
if (extensionRegistry != null) {
// extension registry may be null during testing
extensionRegistry.setSubsystemParentResourceRegistrations(root, deployments);
extensionRegistry.setPathManager(pathManager);
}
// Util
root.registerOperationHandler(
DeployerChainAddHandler.DEFINITION, DeployerChainAddHandler.INSTANCE, false);
}
@Override
public void registerChildren(ManagementResourceRegistration registry) {
super.registerChildren(registry);
registry.registerSubModel(new TransportParamDefinition());
}
@Override
public ManagementResourceRegistration registerSubModel(ResourceDefinition resourceDefinition) {
ManagementResourceRegistration depl = deployments.registerSubModel(resourceDefinition);
ManagementResourceRegistration subdepl = subdeployments.registerSubModel(resourceDefinition);
return new DeploymentManagementResourceRegistration(depl, subdepl);
}
private void registerCommonCacheAttributeHandlers(ManagementResourceRegistration resource) {
// register the singleton=locking handlers
final ManagementResourceRegistration locking =
resource.registerSubModel(lockingPath, InfinispanSubsystemProviders.LOCKING);
locking.registerOperationHandler(
ADD, CacheConfigOperationHandlers.LOCKING_ADD, InfinispanSubsystemProviders.LOCKING_ADD);
locking.registerOperationHandler(
REMOVE, CacheConfigOperationHandlers.REMOVE, InfinispanSubsystemProviders.LOCKING_REMOVE);
CacheConfigOperationHandlers.LOCKING_ATTR.registerAttributes(locking);
// register the singleton=transaction handlers
final ManagementResourceRegistration transaction =
resource.registerSubModel(transactionPath, InfinispanSubsystemProviders.TRANSACTION);
transaction.registerOperationHandler(
ADD,
CacheConfigOperationHandlers.TRANSACTION_ADD,
InfinispanSubsystemProviders.TRANSACTION_ADD);
transaction.registerOperationHandler(
REMOVE,
CacheConfigOperationHandlers.REMOVE,
InfinispanSubsystemProviders.TRANSACTION_REMOVE);
CacheConfigOperationHandlers.TRANSACTION_ATTR.registerAttributes(transaction);
// register the singleton=eviction handlers
final ManagementResourceRegistration eviction =
resource.registerSubModel(evictionPath, InfinispanSubsystemProviders.EVICTION);
eviction.registerOperationHandler(
ADD, CacheConfigOperationHandlers.EVICTION_ADD, InfinispanSubsystemProviders.EVICTION_ADD);
eviction.registerOperationHandler(
REMOVE, CacheConfigOperationHandlers.REMOVE, InfinispanSubsystemProviders.EVICTION_REMOVE);
CacheConfigOperationHandlers.EVICTION_ATTR.registerAttributes(eviction);
// register the singleton=expiration handlers
final ManagementResourceRegistration expiration =
resource.registerSubModel(expirationPath, InfinispanSubsystemProviders.EXPIRATION);
expiration.registerOperationHandler(
ADD,
CacheConfigOperationHandlers.EXPIRATION_ADD,
InfinispanSubsystemProviders.EXPIRATION_ADD);
expiration.registerOperationHandler(
REMOVE,
CacheConfigOperationHandlers.REMOVE,
InfinispanSubsystemProviders.EXPIRATION_REMOVE);
CacheConfigOperationHandlers.LOCKING_ATTR.registerAttributes(expiration);
// register the singleton=state-transfer handlers
final ManagementResourceRegistration stateTransfer =
resource.registerSubModel(stateTransferPath, InfinispanSubsystemProviders.STATE_TRANSFER);
stateTransfer.registerOperationHandler(
ADD,
CacheConfigOperationHandlers.STATE_TRANSFER_ADD,
InfinispanSubsystemProviders.STATE_TRANSFER_ADD);
stateTransfer.registerOperationHandler(
REMOVE,
CacheConfigOperationHandlers.REMOVE,
InfinispanSubsystemProviders.STATE_TRANSFER_REMOVE);
CacheConfigOperationHandlers.STATE_TRANSFER_ATTR.registerAttributes(stateTransfer);
// register the singleton=rehashing handlers
final ManagementResourceRegistration rehashing =
resource.registerSubModel(rehashingPath, InfinispanSubsystemProviders.REHASHING);
rehashing.registerOperationHandler(
ADD,
CacheConfigOperationHandlers.REHASHING_ADD,
InfinispanSubsystemProviders.REHASHING_ADD);
rehashing.registerOperationHandler(
REMOVE, CacheConfigOperationHandlers.REMOVE, InfinispanSubsystemProviders.REHASHING_REMOVE);
CacheConfigOperationHandlers.STATE_TRANSFER_ATTR.registerAttributes(rehashing);
}
public static void createHostRegistry(
final String hostName,
final ManagementResourceRegistration root,
final HostControllerConfigurationPersister configurationPersister,
final HostControllerEnvironment environment,
final HostRunningModeControl runningModeControl,
final HostFileRepository localFileRepository,
final LocalHostControllerInfoImpl hostControllerInfo,
final ServerInventory serverInventory,
final HostFileRepository remoteFileRepository,
final ContentRepository contentRepository,
final DomainController domainController,
final ExtensionRegistry extensionRegistry,
final AbstractVaultReader vaultReader,
final IgnoredDomainResourceRegistry ignoredRegistry,
final ControlledProcessState processState,
final PathManagerService pathManager,
final DelegatingConfigurableAuthorizer authorizer,
final ManagedAuditLogger auditLogger,
final BootErrorCollector bootErrorCollector) {
// Add of the host itself
ManagementResourceRegistration hostRegistration =
root.registerSubModel(
new HostResourceDefinition(
hostName,
configurationPersister,
environment,
runningModeControl,
localFileRepository,
hostControllerInfo,
serverInventory,
remoteFileRepository,
contentRepository,
domainController,
extensionRegistry,
vaultReader,
ignoredRegistry,
processState,
pathManager,
authorizer,
auditLogger,
bootErrorCollector));
// TODO See if some of all these parameters can come from domain controller
LocalDomainControllerAddHandler localDcAddHandler =
LocalDomainControllerAddHandler.getInstance(
root,
hostControllerInfo,
configurationPersister,
localFileRepository,
contentRepository,
domainController,
extensionRegistry,
pathManager);
hostRegistration.registerOperationHandler(
LocalDomainControllerAddHandler.DEFINITION, localDcAddHandler);
hostRegistration.registerOperationHandler(
LocalDomainControllerRemoveHandler.DEFINITION, LocalDomainControllerRemoveHandler.INSTANCE);
RemoteDomainControllerAddHandler remoteDcAddHandler =
new RemoteDomainControllerAddHandler(
root,
hostControllerInfo,
domainController,
configurationPersister,
contentRepository,
remoteFileRepository,
extensionRegistry,
ignoredRegistry,
pathManager);
hostRegistration.registerOperationHandler(
RemoteDomainControllerAddHandler.DEFINITION, remoteDcAddHandler);
hostRegistration.registerOperationHandler(
RemoteDomainControllerRemoveHandler.DEFINITION,
RemoteDomainControllerRemoveHandler.INSTANCE);
}
/**
* {@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);
}
