public synchronized void start(StartContext startContext) throws StartException {
    try {
      final ServiceContainer container = startContext.getController().getServiceContainer();

      deploymentMD = getDeployer().deploy(container);
      if (deploymentMD.getCfs().length != 1) {
        throw ConnectorLogger.ROOT_LOGGER.cannotStartDs();
      }
      sqlDataSource =
          new WildFlyDataSource(
              (javax.sql.DataSource) deploymentMD.getCfs()[0], jndiName.getAbsoluteJndiName());
      DS_DEPLOYER_LOGGER.debugf("Adding datasource: %s", deploymentMD.getCfJndiNames()[0]);
      CommonDeploymentService cdService = new CommonDeploymentService(deploymentMD);
      final ServiceName cdServiceName = CommonDeploymentService.getServiceName(jndiName);
      startContext
          .getController()
          .getServiceContainer()
          .addService(cdServiceName, cdService)
          // The dependency added must be the JNDI name which for subsystem resources is an alias.
          // This service
          // is also used in deployments where the capability service name is not registered for the
          // service.
          .addDependency(getServiceName(jndiName))
          .setInitialMode(ServiceController.Mode.ACTIVE)
          .install();
    } catch (Throwable t) {
      throw ConnectorLogger.ROOT_LOGGER.deploymentError(t, dsName);
    }
  }
  /**
   * Performs the actual work of stopping the service. Should be called by {@link
   * #stop(org.jboss.msc.service.StopContext)} asynchronously from the MSC thread that invoked stop.
   */
  protected synchronized void stopService() {
    if (deploymentMD != null) {

      if (deploymentMD.getResourceAdapterKey() != null) {
        try {
          raRepository.getValue().unregisterResourceAdapter(deploymentMD.getResourceAdapterKey());
        } catch (org.jboss.jca.core.spi.rar.NotFoundException nfe) {
          ConnectorLogger.ROOT_LOGGER.exceptionDuringUnregistering(nfe);
        }
      }

      if (deploymentMD.getResourceAdapter() != null) {
        deploymentMD.getResourceAdapter().stop();

        BootstrapContextCoordinator.getInstance()
            .removeBootstrapContext(deploymentMD.getBootstrapContextIdentifier());
      }

      if (deploymentMD.getDataSources() != null && managementRepositoryValue.getValue() != null) {
        for (org.jboss.jca.core.api.management.DataSource mgtDs : deploymentMD.getDataSources()) {
          managementRepositoryValue.getValue().getDataSources().remove(mgtDs);
        }
      }

      if (deploymentMD.getConnectionManagers() != null) {
        for (ConnectionManager cm : deploymentMD.getConnectionManagers()) {
          cm.shutdown();
        }
      }
    }

    sqlDataSource = null;
  }
  public synchronized void start(StartContext startContext) throws StartException {
    try {
      final ServiceContainer container = startContext.getController().getServiceContainer();

      CommonDeployment deploymentMD = deployer.deploy(container);
      if (deploymentMD.getCfs().length != 1) {
        throw new StartException("unable to start the ds because it generate more than one cf");
      }
      sqlDataSource = (javax.sql.DataSource) deploymentMD.getCfs()[0];
      log.debugf("Adding datasource: %s", deploymentMD.getCfJndiNames()[0]);
    } catch (Throwable t) {
      throw new StartException("Error during the deployment of " + jndiName, t);
    }
  }
  public synchronized void start(StartContext startContext) throws StartException {
    try {
      final ServiceContainer container = startContext.getController().getServiceContainer();

      deploymentMD = getDeployer().deploy(container);
      if (deploymentMD.getCfs().length != 1) {
        throw ConnectorLogger.ROOT_LOGGER.cannotStartDs();
      }
      sqlDataSource =
          new WildFlyDataSource((javax.sql.DataSource) deploymentMD.getCfs()[0], jndiName);
      DS_DEPLOYER_LOGGER.debugf("Adding datasource: %s", deploymentMD.getCfJndiNames()[0]);
    } catch (Throwable t) {
      throw ConnectorLogger.ROOT_LOGGER.deploymentError(t, dsName);
    }
  }
  @Override
  public void start(StartContext context) throws StartException {
    final URL url = connectorXmlDescriptor == null ? null : connectorXmlDescriptor.getUrl();
    deploymentName =
        connectorXmlDescriptor == null ? null : connectorXmlDescriptor.getDeploymentName();
    final File root = connectorXmlDescriptor == null ? null : connectorXmlDescriptor.getRoot();
    DEPLOYMENT_CONNECTOR_LOGGER.debugf("DEPLOYMENT name = %s", deploymentName);
    final AS7RaDeployer raDeployer =
        new AS7RaDeployer(
            context.getChildTarget(),
            url,
            deploymentName,
            root,
            classLoader,
            cmd,
            ijmd,
            deploymentServiceName);
    raDeployer.setConfiguration(config.getValue());

    ClassLoader old = WildFlySecurityManager.getCurrentContextClassLoaderPrivileged();
    try {
      WritableServiceBasedNamingStore.pushOwner(duServiceName);
      WildFlySecurityManager.setCurrentContextClassLoaderPrivileged(classLoader);
      raDeployment = raDeployer.doDeploy();
      deploymentName = raDeployment.getDeploymentName();
    } catch (Throwable t) {
      unregisterAll(deploymentName);
      throw MESSAGES.failedToStartRaDeployment(t, deploymentName);
    } finally {
      WildFlySecurityManager.setCurrentContextClassLoaderPrivileged(old);
      WritableServiceBasedNamingStore.popOwner();
    }

    if (raDeployer.checkActivation(cmd, ijmd)) {
      DEPLOYMENT_CONNECTOR_LOGGER.debugf("Activating: %s", deploymentName);

      ServiceName raServiceName = ConnectorServices.getResourceAdapterServiceName(deploymentName);
      value = new ResourceAdapterDeployment(raDeployment, deploymentName, raServiceName);

      managementRepository.getValue().getConnectors().add(value.getDeployment().getConnector());
      registry.getValue().registerResourceAdapterDeployment(value);

      context
          .getChildTarget()
          .addService(
              raServiceName,
              new ResourceAdapterService(
                  deploymentName, raServiceName, value.getDeployment().getResourceAdapter()))
          .setInitialMode(Mode.ACTIVE)
          .install();
    } else {
      DEPLOYMENT_CONNECTOR_LOGGER.debugf("Not activating: %s", deploymentName);
    }
  }
  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);
        }
    }
  }
  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);
        }
    }
  }