@SuppressWarnings("deprecation") @Override public void registerMetric( String attributeName, OperationStepHandler metricHandler, EnumSet<AttributeAccess.Flag> flags) { deployments.registerMetric(attributeName, metricHandler, flags); subdeployments.registerMetric(attributeName, metricHandler, flags); }
@Override public void registerAttributes(ManagementResourceRegistration resourceRegistration) { super.registerAttributes(resourceRegistration); // Metrics resourceRegistration.registerMetric( BindingMetricHandlers.BoundHandler.ATTRIBUTE_DEFINITION, BindingMetricHandlers.BoundHandler.INSTANCE); resourceRegistration.registerMetric( BindingMetricHandlers.BoundAddressHandler.ATTRIBUTE_DEFINITION, BindingMetricHandlers.BoundAddressHandler.INSTANCE); resourceRegistration.registerMetric( BindingMetricHandlers.BoundPortHandler.ATTRIBUTE_DEFINITION, BindingMetricHandlers.BoundPortHandler.INSTANCE); }
@Override public void registerAttributes(ManagementResourceRegistration resourceRegistration) { MaxRequestsWriteHandler handler = new MaxRequestsWriteHandler(MAX_REQUESTS, requestController); resourceRegistration.registerReadWriteAttribute(MAX_REQUESTS, null, handler); resourceRegistration.registerMetric( ACTIVE_REQUESTS, new ActiveRequestsReadHandler(requestController)); }
@Override public void registerAttributes(ManagementResourceRegistration registry) { super.registerAttributes(registry); AttributeDefinition[] attributes = deployed ? getDeploymentAttributes() : ATTRIBUTES; for (AttributeDefinition attr : attributes) { if (registerRuntimeOnly || !attr.getFlags().contains(AttributeAccess.Flag.STORAGE_RUNTIME)) { if (deployed) { registry.registerReadOnlyAttribute(attr, JMSQueueConfigurationRuntimeHandler.INSTANCE); } else { if (attr == CommonAttributes.DESTINATION_ENTRIES) { registry.registerReadWriteAttribute( attr, null, JMSQueueConfigurationWriteHandler.INSTANCE); } else { registry.registerReadOnlyAttribute(attr, null); } } } } if (registerRuntimeOnly) { for (AttributeDefinition attr : READONLY_ATTRIBUTES) { registry.registerReadOnlyAttribute(attr, JMSQueueReadAttributeHandler.INSTANCE); } for (AttributeDefinition metric : METRICS) { registry.registerMetric(metric, JMSQueueReadAttributeHandler.INSTANCE); } } }
@Override public void registerAttributes(ManagementResourceRegistration resourceRegistration) { resourceRegistration.registerMetric( RESOURCE_CLASS, new AbstractRestResReadHandler() { @Override void handleAttribute( String className, List<JaxrsResourceMethodDescription> methodInvokers, List<JaxrsResourceLocatorDescription> locatorIncokers, Collection<String> servletMappings, ModelNode response) { response.set(className); } }); resourceRegistration.registerMetric( RESOURCE_PATHS, new AbstractRestResReadHandler() { @Override void handleAttribute( String className, List<JaxrsResourceMethodDescription> methodInvokers, List<JaxrsResourceLocatorDescription> locatorIncokers, Collection<String> servletMappings, ModelNode response) { for (JaxrsResourceMethodDescription methodDesc : methodInvokers) { response.add(methodDesc.toModelNode()); } } }); resourceRegistration.registerMetric( SUB_RESOURCE_LOCATORS, new AbstractRestResReadHandler() { @Override void handleAttribute( String className, List<JaxrsResourceMethodDescription> methodInvokers, List<JaxrsResourceLocatorDescription> locatorIncokers, Collection<String> servletMappings, ModelNode response) { for (JaxrsResourceLocatorDescription methodDesc : locatorIncokers) { response.add(methodDesc.toModelNode()); } } }); }
@Override public void registerAttributes(ManagementResourceRegistration resourceRegistration) { resourceRegistration.registerReadOnlyAttribute(CONTEXT_ROOT, null); resourceRegistration.registerReadOnlyAttribute(VIRTUAL_HOST, null); for (SessionStat stat : SessionStat.values()) { resourceRegistration.registerMetric( stat.definition, SessionManagerStatsHandler.getInstance()); } }
@Override protected void register(ManagementResourceRegistration registration) { if (PlatformMBeanUtil.JVM_MAJOR_VERSION > 6) { registration.registerReadOnlyAttribute( PlatformMBeanConstants.OBJECT_NAME, this, AttributeAccess.Storage.RUNTIME); } for (String attribute : PlatformMBeanConstants.MEMORY_MANAGER_READ_ATTRIBUTES) { registration.registerMetric(attribute, this); } }
@Override public void registerAttributes(ManagementResourceRegistration registration) { super.registerAttributes(registration); registration.registerReadOnlyAttribute( PlatformMBeanConstants.OBJECT_NAME, CompilationMXBeanAttributeHandler.INSTANCE); for (SimpleAttributeDefinition attribute : READ_ATTRIBUTES) { registration.registerReadOnlyAttribute(attribute, CompilationMXBeanAttributeHandler.INSTANCE); } for (SimpleAttributeDefinition attribute : METRICS) { registration.registerMetric(attribute, CompilationMXBeanAttributeHandler.INSTANCE); } }
@Override public void registerAttributes(ManagementResourceRegistration resourceRegistration) { // the handlers need to take account of alias final OperationStepHandler writeHandler = new CacheContainerWriteAttributeHandler(CACHE_CONTAINER_ATTRIBUTES); for (AttributeDefinition attr : CACHE_CONTAINER_ATTRIBUTES) { resourceRegistration.registerReadWriteAttribute( attr, CacheContainerReadAttributeHandler.INSTANCE, writeHandler); } for (AttributeDefinition attr : CACHE_CONTAINER_METRICS) { resourceRegistration.registerMetric(attr, CacheContainerMetricsHandler.INSTANCE); } }
@Override public void registerAttributes(ManagementResourceRegistration resourceRegistration) { super.registerAttributes(resourceRegistration); // do we really need a special handler here? final OperationStepHandler writeHandler = new CacheWriteAttributeHandler(CLUSTERED_CACHE_ATTRIBUTES); for (AttributeDefinition attr : CLUSTERED_CACHE_ATTRIBUTES) { resourceRegistration.registerReadWriteAttribute( attr, CacheReadAttributeHandler.INSTANCE, writeHandler); } // register any metrics for (AttributeDefinition attr : CLUSTERED_CACHE_METRICS) { resourceRegistration.registerMetric(attr, CacheMetricsHandler.INSTANCE); } }
@Override public void registerAttributes(ManagementResourceRegistration registry) { super.registerAttributes(registry); for (SimpleAttributeDefinition attr : ATTRIBUTES) { if (!attr.getFlags().contains(AttributeAccess.Flag.STORAGE_RUNTIME)) { if (runtimeOnly) { AttributeDefinition readOnlyRuntimeAttr = create(attr).setStorageRuntime().build(); registry.registerReadOnlyAttribute( readOnlyRuntimeAttr, QueueReadAttributeHandler.RUNTIME_INSTANCE); } else { registry.registerReadOnlyAttribute(attr, null); } } } for (AttributeDefinition attr : READONLY_ATTRIBUTES) { registry.registerReadOnlyAttribute(attr, QueueReadAttributeHandler.INSTANCE); } for (AttributeDefinition metric : METRICS) { registry.registerMetric(metric, QueueReadAttributeHandler.INSTANCE); } }
@Override public void registerMetric(AttributeDefinition definition, OperationStepHandler metricHandler) { deployments.registerMetric(definition, metricHandler); subdeployments.registerMetric(definition, metricHandler); }
@SuppressWarnings("deprecation") @Override public void registerMetric(String attributeName, OperationStepHandler metricHandler) { deployments.registerMetric(attributeName, metricHandler); subdeployments.registerMetric(attributeName, metricHandler); }
public void transition( final ServiceController<? extends Object> controller, final ServiceController.Transition transition) { switch (transition) { case STARTING_to_UP: { CommonDeployment deploymentMD = getDeploymentMetadata(controller); if (deploymentMD.getConnectionManagers() != null) { for (ConnectionManager cm : deploymentMD.getConnectionManagers()) { if (cm.getPool() != null) { StatisticsPlugin poolStats = cm.getPool().getStatistics(); if (poolStats.getNames().size() != 0) { DescriptionProvider statsResourceDescriptionProvider = new StatisticsDescriptionProvider( ResourceAdaptersSubsystemProviders.RESOURCE_NAME, "statistics", poolStats); PathElement pe = PathElement.pathElement( ModelDescriptionConstants.SUBSYSTEM, ResourceAdaptersExtension.SUBSYSTEM_NAME); PathElement peStats = PathElement.pathElement(Constants.STATISTICS_NAME, Constants.STATISTICS_NAME); PathElement peCD = PathElement.pathElement( Constants.CONNECTIONDEFINITIONS_NAME, cm.getJndiName()); ManagementResourceRegistration overrideRegistration = registration; // when you are in deploy you have a registration pointing to deployment=* // when you are in re-deploy it points to specific deploymentUnit synchronized (this) { if (registration.isAllowsOverride() && registration.getOverrideModel(deploymentUnitName) == null) { overrideRegistration = registration.registerOverrideModel( deploymentUnitName, new OverrideDescriptionProvider() { @Override public Map<String, ModelNode> getAttributeOverrideDescriptions( Locale locale) { return Collections.emptyMap(); } @Override public Map<String, ModelNode> getChildTypeOverrideDescriptions( Locale locale) { return Collections.emptyMap(); } }); } else { overrideRegistration = registration.getOverrideModel(deploymentUnitName); } ManagementResourceRegistration subRegistration = overrideRegistration.getSubModel(PathAddress.pathAddress(pe)); if (subRegistration == null) { subRegistration = overrideRegistration.registerSubModel( pe, new SubSystemExtensionDescriptionProvider( ResourceAdaptersSubsystemProviders.RESOURCE_NAME, "deployment-subsystem")); } Resource subsystemResource; if (!deploymentResource.hasChild(pe)) { subsystemResource = new IronJacamarResource.IronJacamarRuntimeResource(); deploymentResource.registerChild(pe, subsystemResource); } else { subsystemResource = deploymentResource.getChild(pe); } ManagementResourceRegistration statsRegistration = subRegistration.getSubModel(PathAddress.pathAddress(peStats)); if (statsRegistration == null) { statsRegistration = subRegistration.registerSubModel( peStats, new StatisticsElementDescriptionProvider( ResourceAdaptersSubsystemProviders.RESOURCE_NAME, "statistics")); } Resource statisticsResource; if (!subsystemResource.hasChild(peStats)) { statisticsResource = new IronJacamarResource.IronJacamarRuntimeResource(); subsystemResource.registerChild(peStats, statisticsResource); } else { statisticsResource = subsystemResource.getChild(peStats); } if (statsRegistration.getSubModel(PathAddress.pathAddress(peCD)) == null) { ManagementResourceRegistration cdSubRegistration = statsRegistration.registerSubModel( peCD, statsResourceDescriptionProvider); final Resource cdResource = new IronJacamarResource.IronJacamarRuntimeResource(); if (!statisticsResource.hasChild(peCD)) statisticsResource.registerChild(peCD, cdResource); for (String statName : poolStats.getNames()) { cdSubRegistration.registerMetric( statName, new PoolMetrics.ParametrizedPoolMetricsHandler(poolStats)); } cdSubRegistration.registerOperationHandler( "clear-statistics", new ClearStatisticsHandler(poolStats), ResourceAdaptersSubsystemProviders.CLEAR_STATISTICS_DESC, false); } registerIronjacamar(controller, subRegistration, subsystemResource); } } } } } break; } case UP_to_STOP_REQUESTED: { PathElement pe = PathElement.pathElement( ModelDescriptionConstants.SUBSYSTEM, ResourceAdaptersExtension.SUBSYSTEM_NAME); PathElement ijPe = PathElement.pathElement(Constants.IRONJACAMAR_NAME, Constants.IRONJACAMAR_NAME); PathElement peStats = PathElement.pathElement(Constants.STATISTICS_NAME, Constants.STATISTICS_NAME); PathElement peCD = PathElement.pathElement(Constants.CONNECTIONDEFINITIONS_NAME); ManagementResourceRegistration overrideRegistration = registration; // when you are in deploy you have a registration pointing to deployment=* // when you are in re-deploy it points to specific deploymentUnit if (registration.isAllowsOverride() && registration.getOverrideModel(deploymentUnitName) != null) { overrideRegistration = registration.getOverrideModel(deploymentUnitName); } ManagementResourceRegistration subsystemReg = overrideRegistration.getSubModel(PathAddress.pathAddress(pe)); if (subsystemReg != null) { if (subsystemReg.getSubModel(PathAddress.pathAddress(ijPe)) != null) { subsystemReg.unregisterSubModel(ijPe); } ManagementResourceRegistration statsReg = subsystemReg.getSubModel(PathAddress.pathAddress(peStats)); if (statsReg != null) { if (statsReg.getSubModel(PathAddress.pathAddress(peCD)) != null) { statsReg.unregisterSubModel(peCD); } subsystemReg.unregisterSubModel(peStats); } overrideRegistration.unregisterSubModel(pe); } deploymentResource.removeChild(pe); } } }
@Override public void initialize(final ExtensionContext context) { SUBSYSTEM_RA_LOGGER.debugf("Initializing ResourceAdapters Extension"); // Register the remoting subsystem final SubsystemRegistration registration = context.registerSubsystem(SUBSYSTEM_NAME); ReloadRequiredWriteAttributeHandler reloadRequiredWriteAttributeHandler = new ReloadRequiredWriteAttributeHandler(); registration.registerXMLElementWriter(ResourceAdapterSubsystemParser.INSTANCE); // Remoting subsystem description and operation handlers final ManagementResourceRegistration subsystem = registration.registerSubsystemModel(SUBSYSTEM); subsystem.registerOperationHandler( ADD, ResourceAdaptersSubSystemAdd.INSTANCE, SUBSYSTEM_ADD_DESC, false); subsystem.registerOperationHandler( DESCRIBE, GenericSubsystemDescribeHandler.INSTANCE, GenericSubsystemDescribeHandler.INSTANCE, false, OperationEntry.EntryType.PRIVATE); final ManagementResourceRegistration resourceadapter = subsystem.registerSubModel( PathElement.pathElement(RESOURCEADAPTER_NAME), RESOURCEADAPTER_DESC); resourceadapter.registerOperationHandler(ADD, RaAdd.INSTANCE, ADD_RESOURCEADAPTER_DESC, false); resourceadapter.registerOperationHandler( REMOVE, RaRemove.INSTANCE, REMOVE_RESOURCEADAPTER_DESC, false); for (final String attribute : ResourceAdaptersSubsystemProviders.RESOURCEADAPTER_ATTRIBUTE) { resourceadapter.registerReadWriteAttribute( attribute, null, reloadRequiredWriteAttributeHandler, Storage.CONFIGURATION); } final ManagementResourceRegistration configAdapter = resourceadapter.registerSubModel( PathElement.pathElement(CONFIG_PROPERTIES.getName()), CONFIG_PROPERTIES_DESC); configAdapter.registerOperationHandler( ADD, ConfigPropertyAdd.INSTANCE, ADD_CONFIG_PROPERTIES_DESC, false); configAdapter.registerOperationHandler( REMOVE, ReloadRequiredRemoveStepHandler.INSTANCE, REMOVE_CONFIG_PROPERTIES_DESC, false); final ManagementResourceRegistration connectionDefinition = resourceadapter.registerSubModel( PathElement.pathElement(CONNECTIONDEFINITIONS_NAME), CONNECTION_DEFINITION_DESC); connectionDefinition.registerOperationHandler( ADD, ConnectionDefinitionAdd.INSTANCE, ADD_CONNECTION_DEFINITION_DESC, false); connectionDefinition.registerOperationHandler( REMOVE, ReloadRequiredRemoveStepHandler.INSTANCE, REMOVE_CONNECTION_DEFINITION_DESC, false); final ManagementResourceRegistration configCF = connectionDefinition.registerSubModel( PathElement.pathElement(CONFIG_PROPERTIES.getName()), CONFIG_PROPERTIES_DESC); configCF.registerOperationHandler( ADD, CDConfigPropertyAdd.INSTANCE, ADD_CONFIG_PROPERTIES_DESC, false); configCF.registerOperationHandler( REMOVE, ReloadRequiredRemoveStepHandler.INSTANCE, REMOVE_CONFIG_PROPERTIES_DESC, false); for (final SimpleAttributeDefinition attribute : ResourceAdaptersSubsystemProviders.CONNECTIONDEFINITIONS_NODEATTRIBUTE) { connectionDefinition.registerReadWriteAttribute( attribute.getName(), null, reloadRequiredWriteAttributeHandler, Storage.CONFIGURATION); } final ManagementResourceRegistration adminObject = resourceadapter.registerSubModel( PathElement.pathElement(ADMIN_OBJECTS_NAME), ADMIN_OBJECT_DESC); adminObject.registerOperationHandler( ADD, AdminObjectAdd.INSTANCE, ADD_ADMIN_OBJECT_DESC, false); adminObject.registerOperationHandler( REMOVE, ReloadRequiredRemoveStepHandler.INSTANCE, REMOVE_ADMIN_OBJECT_DESC, false); final ManagementResourceRegistration configAO = adminObject.registerSubModel( PathElement.pathElement(CONFIG_PROPERTIES.getName()), CONFIG_PROPERTIES_DESC); configAO.registerOperationHandler( ADD, AOConfigPropertyAdd.INSTANCE, ADD_CONFIG_PROPERTIES_DESC, false); configAO.registerOperationHandler( REMOVE, ReloadRequiredRemoveStepHandler.INSTANCE, REMOVE_CONFIG_PROPERTIES_DESC, false); for (final SimpleAttributeDefinition attribute : ResourceAdaptersSubsystemProviders.ADMIN_OBJECTS_NODEATTRIBUTE) { adminObject.registerReadWriteAttribute( attribute.getName(), null, reloadRequiredWriteAttributeHandler, Storage.CONFIGURATION); } resourceadapter.registerOperationHandler( "flush-idle-connection-in-pool", PoolOperations.FlushIdleConnectionInPool.RA_INSTANCE, FLUSH_IDLE_CONNECTION_DESC, false); resourceadapter.registerOperationHandler( "flush-all-connection-in-pool", PoolOperations.FlushAllConnectionInPool.RA_INSTANCE, FLUSH_ALL_CONNECTION_DESC, false); resourceadapter.registerOperationHandler( "test-connection-in-pool", PoolOperations.TestConnectionInPool.RA_INSTANCE, TEST_CONNECTION_DESC, false); for (final String attributeName : PoolMetrics.ATTRIBUTES) { resourceadapter.registerMetric(attributeName, PoolMetrics.RaPoolMetricsHandler.INSTANCE); } }
public void transition( final ServiceController<? extends Object> controller, final ServiceController.Transition transition) { switch (transition) { case STARTING_to_UP: { CommonDeployment deploymentMD = getDeploymentMetadata(controller); if (deploymentMD.getConnectionManagers() != null) { for (ConnectionManager cm : deploymentMD.getConnectionManagers()) { if (cm.getPool() != null) { StatisticsPlugin poolStats = cm.getPool().getStatistics(); poolStats.setEnabled(false); final ServiceController<?> bootstrapContextController = controller .getServiceContainer() .getService( ConnectorServices.BOOTSTRAP_CONTEXT_SERVICE.append(bootstrapCtx)); WorkManager wm = null; if (bootstrapContextController != null) { wm = (WorkManager) ((CloneableBootstrapContext) bootstrapContextController.getValue()) .getWorkManager(); } if ((wm != null && wm.getStatistics() != null) || poolStats.getNames().size() != 0) { PathElement pe = PathElement.pathElement( ModelDescriptionConstants.SUBSYSTEM, ResourceAdaptersExtension.SUBSYSTEM_NAME); PathElement peStats = PathElement.pathElement(Constants.STATISTICS_NAME, Constants.STATISTICS_NAME); PathElement peRa = PathElement.pathElement(Constants.RESOURCEADAPTER_NAME, raName); PathElement peWm = PathElement.pathElement(Constants.WORKMANAGER_NAME, wm.getName()); PathElement peDistributedWm = PathElement.pathElement(Constants.DISTRIBUTED_WORKMANAGER_NAME, wm.getName()); PathElement peCD = PathElement.pathElement( Constants.CONNECTIONDEFINITIONS_NAME, cm.getJndiName()); ManagementResourceRegistration overrideRegistration = registration; // when you are in deploy you have a registration pointing to deployment=* // when you are in re-deploy it points to specific deploymentUnit synchronized (this) { if (registration.isAllowsOverride()) { if (registration.getOverrideModel(deploymentUnitName) != null) { overrideRegistration = registration.getOverrideModel(deploymentUnitName); } else { overrideRegistration = registration.registerOverrideModel( deploymentUnitName, new OverrideDescriptionProvider() { @Override public Map<String, ModelNode> getAttributeOverrideDescriptions( Locale locale) { return Collections.emptyMap(); } @Override public Map<String, ModelNode> getChildTypeOverrideDescriptions( Locale locale) { return Collections.emptyMap(); } }); } } ManagementResourceRegistration subRegistration; try { ResourceBuilder resourceBuilder = ResourceBuilder.Factory.create( pe, new StandardResourceDescriptionResolver( Constants.STATISTICS_NAME, CommonAttributes.RESOURCE_NAME, CommonAttributes.class.getClassLoader())); subRegistration = overrideRegistration.registerSubModel(resourceBuilder.build()); } catch (IllegalArgumentException iae) { subRegistration = overrideRegistration.getSubModel(PathAddress.pathAddress(pe)); } Resource subsystemResource; if (!deploymentResource.hasChild(pe)) { subsystemResource = new IronJacamarResource.IronJacamarRuntimeResource(); deploymentResource.registerChild(pe, subsystemResource); } else { subsystemResource = deploymentResource.getChild(pe); } ManagementResourceRegistration statsRegistration; try { ResourceBuilder resourceBuilder = ResourceBuilder.Factory.create( peStats, new StandardResourceDescriptionResolver( Constants.STATISTICS_NAME, CommonAttributes.RESOURCE_NAME, CommonAttributes.class.getClassLoader())); statsRegistration = subRegistration.registerSubModel(resourceBuilder.build()); } catch (IllegalArgumentException iae) { statsRegistration = subRegistration.getSubModel(PathAddress.pathAddress(peStats)); } Resource statisticsResource; if (!subsystemResource.hasChild(peStats)) { statisticsResource = new IronJacamarResource.IronJacamarRuntimeResource(); subsystemResource.registerChild(peStats, statisticsResource); } else { statisticsResource = subsystemResource.getChild(peStats); } ManagementResourceRegistration raRegistration; try { ResourceBuilder resourceBuilder = ResourceBuilder.Factory.create( peRa, new StandardResourceDescriptionResolver( Constants.STATISTICS_NAME, CommonAttributes.RESOURCE_NAME, CommonAttributes.class.getClassLoader())); raRegistration = statsRegistration.registerSubModel(resourceBuilder.build()); } catch (IllegalArgumentException iae) { raRegistration = statsRegistration.getSubModel(PathAddress.pathAddress(peRa)); } Resource raResource; if (!statisticsResource.hasChild(peRa)) { raResource = new IronJacamarResource.IronJacamarRuntimeResource(); statisticsResource.registerChild(peRa, raResource); } else { raResource = statisticsResource.getChild(peRa); } if (deploymentMD.getConnector() != null && deploymentMD.getConnector().getResourceAdapter() != null && deploymentMD.getConnector().getResourceAdapter().getStatistics() != null) { StatisticsPlugin raStats = deploymentMD.getConnector().getResourceAdapter().getStatistics(); raStats.setEnabled(false); PoolMetrics.ParametrizedPoolMetricsHandler handler = new PoolMetrics.ParametrizedPoolMetricsHandler(raStats); for (AttributeDefinition attribute : StatisticsResourceDefinition.getAttributesFromPlugin(raStats)) { raRegistration.registerMetric(attribute, handler); } // adding enable/disable for pool stats OperationStepHandler readHandler = new PoolStatisticsRuntimeAttributeReadHandler(raStats); OperationStepHandler writeHandler = new PoolStatisticsRuntimeAttributeWriteHandler(raStats); raRegistration.registerReadWriteAttribute( org.jboss.as.connector.subsystems.common.pool.Constants .POOL_STATISTICS_ENABLED, readHandler, writeHandler); } if (poolStats.getNames().size() != 0 && raRegistration.getSubModel(PathAddress.pathAddress(peCD)) == null) { ManagementResourceRegistration cdSubRegistration = raRegistration.registerSubModel( new StatisticsResourceDefinition( peCD, CommonAttributes.RESOURCE_NAME, poolStats)); final Resource cdResource = new IronJacamarResource.IronJacamarRuntimeResource(); if (!raResource.hasChild(peCD)) raResource.registerChild(peCD, cdResource); } if (wm.getStatistics() != null) { if (wm instanceof DistributedWorkManager && ((DistributedWorkManager) wm).getDistributedStatistics() != null && raRegistration.getSubModel(PathAddress.pathAddress(peDistributedWm)) == null) { ResourceBuilder resourceBuilder = ResourceBuilder.Factory.create( peDistributedWm, new StandardResourceDescriptionResolver( Constants.STATISTICS_NAME + "." + Constants.WORKMANAGER_NAME, CommonAttributes.RESOURCE_NAME, CommonAttributes.class.getClassLoader())); ManagementResourceRegistration dwmSubRegistration = raRegistration.registerSubModel(resourceBuilder.build()); final Resource dwmResource = new IronJacamarResource.IronJacamarRuntimeResource(); if (!raResource.hasChild(peDistributedWm)) raResource.registerChild(peDistributedWm, dwmResource); OperationStepHandler metricsHandler = new WorkManagerRuntimeAttributeReadHandler( wm, ((DistributedWorkManager) wm).getDistributedStatistics(), false); for (SimpleAttributeDefinition metric : Constants.WORKMANAGER_METRICS) { dwmSubRegistration.registerMetric(metric, metricsHandler); } OperationStepHandler readHandler = new WorkManagerRuntimeAttributeReadHandler( wm, ((DistributedWorkManager) wm).getDistributedStatistics(), true); OperationStepHandler writeHandler = new WorkManagerRuntimeAttributeWriteHandler( wm, true, Constants.DISTRIBUTED_WORKMANAGER_RW_ATTRIBUTES); for (SimpleAttributeDefinition attribute : Constants.DISTRIBUTED_WORKMANAGER_RW_ATTRIBUTES) { dwmSubRegistration.registerReadWriteAttribute( attribute, readHandler, writeHandler); } dwmSubRegistration.registerOperationHandler( ClearWorkManagerStatisticsHandler.DEFINITION, new ClearWorkManagerStatisticsHandler(wm)); } if (raRegistration.getSubModel(PathAddress.pathAddress(peWm)) == null) { ResourceBuilder resourceBuilder = ResourceBuilder.Factory.create( peWm, new StandardResourceDescriptionResolver( Constants.STATISTICS_NAME + "." + Constants.WORKMANAGER_NAME, CommonAttributes.RESOURCE_NAME, CommonAttributes.class.getClassLoader())); ManagementResourceRegistration wmSubRegistration = raRegistration.registerSubModel(resourceBuilder.build()); final Resource wmResource = new IronJacamarResource.IronJacamarRuntimeResource(); if (!raResource.hasChild(peWm)) raResource.registerChild(peWm, wmResource); OperationStepHandler metricHandler = new WorkManagerRuntimeAttributeReadHandler( wm, wm.getStatistics(), false); for (SimpleAttributeDefinition metric : Constants.WORKMANAGER_METRICS) { wmSubRegistration.registerMetric(metric, metricHandler); } OperationStepHandler readHandler = new WorkManagerRuntimeAttributeReadHandler( wm, wm.getStatistics(), false); OperationStepHandler writeHandler = new WorkManagerRuntimeAttributeWriteHandler( wm, false, Constants.WORKMANAGER_RW_ATTRIBUTES); for (SimpleAttributeDefinition attribute : Constants.WORKMANAGER_RW_ATTRIBUTES) { wmSubRegistration.registerReadWriteAttribute( attribute, readHandler, writeHandler); } wmSubRegistration.registerOperationHandler( ClearWorkManagerStatisticsHandler.DEFINITION, new ClearWorkManagerStatisticsHandler(wm)); } } registerIronjacamar(controller, subRegistration, subsystemResource); } } } } } break; } case UP_to_STOP_REQUESTED: { PathElement pe = PathElement.pathElement( ModelDescriptionConstants.SUBSYSTEM, ResourceAdaptersExtension.SUBSYSTEM_NAME); PathElement ijPe = PathElement.pathElement(Constants.IRONJACAMAR_NAME, Constants.IRONJACAMAR_NAME); PathElement peStats = PathElement.pathElement(Constants.STATISTICS_NAME, Constants.STATISTICS_NAME); PathElement peCD = PathElement.pathElement(Constants.CONNECTIONDEFINITIONS_NAME); ManagementResourceRegistration overrideRegistration = registration; // when you are in deploy you have a registration pointing to deployment=* // when you are in re-deploy it points to specific deploymentUnit if (registration.isAllowsOverride() && registration.getOverrideModel(deploymentUnitName) != null) { overrideRegistration = registration.getOverrideModel(deploymentUnitName); } ManagementResourceRegistration subsystemReg = overrideRegistration.getSubModel(PathAddress.pathAddress(pe)); if (subsystemReg != null) { if (subsystemReg.getSubModel(PathAddress.pathAddress(ijPe)) != null) { subsystemReg.unregisterSubModel(ijPe); } ManagementResourceRegistration statsReg = subsystemReg.getSubModel(PathAddress.pathAddress(peStats)); if (statsReg != null) { if (statsReg.getSubModel(PathAddress.pathAddress(peCD)) != null) { statsReg.unregisterSubModel(peCD); } subsystemReg.unregisterSubModel(peStats); } overrideRegistration.unregisterSubModel(pe); } deploymentResource.removeChild(pe); } } }