@Override
  public void start(StartContext context) throws StartException {
    ROOT_LOGGER.debugf("Starting JCA WorkManager: ", value.getName());

    BlockingExecutor longRunning = (BlockingExecutor) executorLong.getOptionalValue();
    if (longRunning != null) {
      this.value.setLongRunningThreadPool(longRunning);
      this.value.setShortRunningThreadPool((BlockingExecutor) executorShort.getValue());
    } else {
      this.value.setLongRunningThreadPool((BlockingExecutor) executorShort.getValue());
      this.value.setShortRunningThreadPool((BlockingExecutor) executorShort.getValue());
    }

    this.value.setXATerminator(new XATerminatorImpl(xaTerminator.getValue()));

    if (value.getName().equals(DEFAULT_NAME)) {
      WorkManagerCoordinator.getInstance().setDefaultWorkManager(value);
    } else {
      WorkManagerCoordinator.getInstance().registerWorkManager(value);
    }

    // this is a value.restart() equivalent
    if (value.isShutdown()) value.cancelShutdown();

    ROOT_LOGGER.debugf("Started JCA WorkManager: ", value.getName());
  }
  @Override
  public void stop(StopContext context) {
    ROOT_LOGGER.debugf("Stopping JCA WorkManager: ", value.getName());

    // shutting down immediately (synchronous method) the workmanager and release all works
    value.shutdown();

    if (value.getName().equals(DEFAULT_NAME)) {
      WorkManagerCoordinator.getInstance().setDefaultWorkManager(null);
    } else {
      WorkManagerCoordinator.getInstance().unregisterWorkManager(value);
    }

    ROOT_LOGGER.debugf("Stopped JCA WorkManager: ", value.getName());
  }
  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);
        }
    }
  }