/**
   * 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;
  }
예제 #2
0
  /** {@inheritDoc} */
  public boolean testConnection() {
    try {
      ConnectionManager cm = (ConnectionManager) getConnectionListenerFactory();
      ManagedConnectionFactory mcf = getManagedConnectionFactory();

      Subject subject = createSubject(cm.getSubjectFactory(), cm.getSecurityDomain(), mcf);

      if (subject != null) return internalTestConnection(null, subject);
    } catch (Throwable t) {
      log.debug("Error during testConnection: " + t.getMessage(), t);
    }

    return false;
  }
  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);
        }
    }
  }