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