@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); }