org.jboss.msc.service.ServiceContainer Java Examples

@Before
public void setupController() throws InterruptedException {
    container = ServiceContainer.Factory.create("test");
    ServiceTarget target = container.subTarget();

    this.controlledProcessState = new ControlledProcessState(true);

    ServiceBuilder<?> sb = target.addService(ServiceName.of("ModelController"));
    this.caSupplier = sb.requires(CONSOLE_AVAILABILITY_CAPABILITY.getCapabilityServiceName());

    ConsoleAvailabilityControllerTmp caService = new ConsoleAvailabilityControllerTmp(controlledProcessState);

    ControlledProcessStateService.addService(target, controlledProcessState);
    ConsoleAvailabilityService.addService(target, () -> {});

    sb.setInstance(caService)
            .install();

    caService.awaitStartup(30, TimeUnit.SECONDS);
}
 

@Test
public void testInstallSubsystemXmlPlatformPlugins() throws Exception {
  String subsystemXml = FileUtils.readFile(SUBSYSTEM_WITH_PROCESS_ENGINES_ELEMENT_ONLY);

  KernelServices services = createKernelServicesBuilder(null)
      .setSubsystemXml(subsystemXml)
      .build();

  ServiceContainer container = services.getContainer();
  ServiceController<?> serviceController = container.getService(ServiceNames.forBpmPlatformPlugins());
  assertNotNull(serviceController);
  Object platformPlugins = serviceController.getValue();
  assertTrue(platformPlugins instanceof BpmPlatformPlugins);
  assertNotNull(platformPlugins);
  List<BpmPlatformPlugin> plugins = ((BpmPlatformPlugins) platformPlugins).getPlugins();
  assertEquals(1, plugins.size());
  assertTrue(plugins.get(0) instanceof ExampleBpmPlatformPlugin);
}
 

@Test
public void testInstallSubsystemWithEnginesXml() throws Exception {
  String subsystemXml = FileUtils.readFile(SUBSYSTEM_WITH_ENGINES);

  KernelServices services = createKernelServicesBuilder(null)
      .setSubsystemXml(subsystemXml)
      .build();


  ServiceContainer container = services.getContainer();
  assertNotNull("platform service should be installed", container.getService(PLATFORM_SERVICE_NAME));
  assertNotNull("process engine service should be bound in JNDI", container.getService(processEngineServiceBindingServiceName));

  assertNotNull("process engine controller for engine __default is installed ", container.getService(ServiceNames.forManagedProcessEngine("__default")));
  assertNotNull("process engine controller for engine __test is installed ", container.getService(ServiceNames.forManagedProcessEngine("__test")));
}
 

@Test
public void testHttpEndpoint() throws Exception {

    ServiceContainer container = ServiceLocator.getServiceContainer();
    ServiceName hostServiceName = UndertowService.virtualHostName("default-server", "default-host");
    Host host = (Host) container.getRequiredService(hostServiceName).getValue();

    final StringBuilder result = new StringBuilder();
    host.registerHandler("/myapp/myservice", new HttpHandler() {
        @Override
        public void handleRequest(HttpServerExchange exchange) throws Exception {
            String name = exchange.getQueryParameters().get("name").getFirst();
            result.append("Hello " + name);
        }});

    HttpResponse response = HttpRequest.get("http://localhost:8080/myapp/myservice?name=Kermit").getResponse();
    Assert.assertEquals(HttpURLConnection.HTTP_OK, response.getStatusCode());
    Assert.assertEquals("Hello Kermit", result.toString());
}
 

ContextCreateHandlerRegistryImpl(final ServiceContainer serviceContainer, final ServiceTarget serviceTarget) {

            // Setup the default handlers
            addContextCreateHandler(null, new ModuleClassLoaderAssociationHandler());
            addContextCreateHandler(null, new ClassResolverAssociationHandler());
            addContextCreateHandler(null, new ComponentResolverAssociationHandler(subsystemState));

            subsystemState.processExtensions(new Consumer<CamelSubsytemExtension>() {
                @Override
                public void accept(CamelSubsytemExtension plugin) {
                    ContextCreateHandler handler = plugin.getContextCreateHandler(serviceContainer, serviceTarget, subsystemState);
                    if (handler != null) {
                        addContextCreateHandler(null, handler);
                    }
                }
            });
        }
 

@Test
public void testInstallSubsystemWithSingleEngineXml() throws Exception {
  String subsystemXml = FileUtils.readFile(SUBSYSTEM_WITH_SINGLE_ENGINE);

  KernelServices services = createKernelServicesBuilder(null)
      .setSubsystemXml(subsystemXml)
      .build();
  ServiceContainer container = services.getContainer();

  assertNotNull("platform service should be installed", container.getService(PLATFORM_SERVICE_NAME));
  assertNotNull("process engine service should be bound in JNDI", container.getService(processEngineServiceBindingServiceName));

  assertNotNull("process engine controller for engine __default is installed ", container.getService(ServiceNames.forManagedProcessEngine("__default")));

  String persistedSubsystemXml = services.getPersistedSubsystemXml();
  compareXml(null, subsystemXml, persistedSubsystemXml);
}
 

@Before
public void setupController() throws InterruptedException {
    container = ServiceContainer.Factory.create("test");
    ServiceTarget target = container.subTarget();
    if (useDelegateRootResourceDefinition) {
        initializer = createInitializer();
        controllerService = new ModelControllerService(getAuditLogger(), rootResourceDefinition);
    } else {
        controllerService = new ModelControllerService(getAuditLogger());
    }
    ServiceBuilder<ModelController> builder = target.addService(ServiceName.of("ModelController"), controllerService);
    builder.install();
    controllerService.awaitStartup(30, TimeUnit.SECONDS);
    controller = controllerService.getValue();
    //ModelNode setup = Util.getEmptyOperation("setup", new ModelNode());
    //controller.execute(setup, null, null, null);
}
 

@Test
  public void testInstallSubsystemXmlWithEnginesAndJobExecutor() throws Exception {
    String subsystemXml = FileUtils.readFile(SUBSYSTEM_WITH_PROCESS_ENGINES_AND_JOB_EXECUTOR);
//    System.out.println(normalizeXML(subsystemXml));
    KernelServices services = createKernelServicesBuilder(null)
        .setSubsystemXml(subsystemXml)
        .build();
    ServiceContainer container = services.getContainer();
//    container.dumpServices();

    assertNotNull("platform service should be installed", container.getService(PLATFORM_SERVICE_NAME));
    assertNotNull("platform jobexecutor service should be installed", container.getService(PLATFORM_JOBEXECUTOR_SERVICE_NAME));
    assertNotNull("process engine service should be bound in JNDI", container.getService(processEngineServiceBindingServiceName));

    assertNotNull("process engine controller for engine __default is installed ", container.getService(ServiceNames.forManagedProcessEngine("__default")));
    assertNotNull("process engine controller for engine __test is installed ", container.getService(ServiceNames.forManagedProcessEngine("__test")));


    String persistedSubsystemXml = services.getPersistedSubsystemXml();
//    System.out.println(persistedSubsystemXml);
    compareXml(null, subsystemXml, persistedSubsystemXml);
  }
 

@Before
public void setupController() throws InterruptedException {

    // restore default
    blockObject = new CountDownLatch(1);
    latch = new CountDownLatch(1);

    System.out.println("=========  New Test \n");
    container = ServiceContainer.Factory.create("test");
    ServiceTarget target = container.subTarget();
    ModelControllerService svc = new ModelControllerService();
    target.addService(ServiceName.of("ModelController")).setInstance(svc).install();
    svc.awaitStartup(30, TimeUnit.SECONDS);
    controller = svc.getValue();
    ModelNode setup = Util.getEmptyOperation("setup", new ModelNode());
    controller.execute(setup, null, null, null);

    client = controller.createClient(executor);

    managementControllerResource = svc.managementControllerResource;
}
 

@Before
public void setupController() throws InterruptedException {

    container = ServiceContainer.Factory.create("test");
    ServiceTarget target = container.subTarget();
    ModelControllerService svc = new ModelControllerService();
    target.addService(ServiceName.of("ModelController")).setInstance(svc).install();
    sharedState = svc.getSharedState();
    svc.awaitStartup(30, TimeUnit.SECONDS);
    controller = svc.getValue();
    ModelNode setup = Util.getEmptyOperation("setup", new ModelNode());
    controller.execute(setup, null, null, null);
    notificationHandler = new ServiceNotificationHandler();
    controller.getNotificationRegistry().registerNotificationHandler(PathAddress.pathAddress(CORE_SERVICE, MANAGEMENT).append(SERVICE, MANAGEMENT_OPERATIONS), notificationHandler, notificationHandler);
    assertEquals(ControlledProcessState.State.RUNNING, svc.getCurrentProcessState());
}
 

private ManagementResourceRegistration setupController(TestResourceDefinition resourceDefinition) throws InterruptedException {

        // restore default
        blockObject = new CountDownLatch(1);
        latch = new CountDownLatch(1);

        System.out.println("=========  New Test \n");
        container = ServiceContainer.Factory.create(TEST_METRIC);
        ServiceTarget target = container.subTarget();
        ModelControllerService svc = new ModelControllerService(resourceDefinition);
        target.addService(ServiceName.of("ModelController")).setInstance(svc).install();
        svc.awaitStartup(30, TimeUnit.SECONDS);
        controller = svc.getValue();
        ModelNode setup = Util.getEmptyOperation("setup", new ModelNode());
        controller.execute(setup, null, null, null);

        client = controller.createClient(executor);

        return svc.managementControllerResource;
    }
 

@Test
public void testRemoveNonExistingResource() throws Exception {
    container = ServiceContainer.Factory.create("test");
    ServiceTarget target = container.subTarget();
    TestModelControllerService svc = new InterleavedSubsystemModelControllerService();
    target.addService(ServiceName.of("ModelController")).setInstance(svc).install();
    svc.awaitStartup(30, TimeUnit.SECONDS);
    ModelController controller = svc.getValue();

    final PathAddress attributePath = PathAddress.pathAddress(PathElement.pathElement("subsystem", "a"))
            .append(PathElement.pathElement(SUBMODEL_NAME, "nonExisting"));
    final ModelNode op = Util.createEmptyOperation(REMOVE, attributePath);
    ModelNode result = controller.execute(op, null, null, null);

    Assert.assertEquals("failed", result.get("outcome").asString());
}
 

@Test
public void testRemoveExistingResource() throws Exception {
    container = ServiceContainer.Factory.create("test");
    ServiceTarget target = container.subTarget();
    TestModelControllerService svc = new InterleavedSubsystemModelControllerService();
    target.addService(ServiceName.of("ModelController")).setInstance(svc).install();
    svc.awaitStartup(30, TimeUnit.SECONDS);
    ModelController controller = svc.getValue();

    // create child node
    final PathAddress attributePath = PathAddress.pathAddress(PathElement.pathElement("subsystem", "a"))
            .append(PathElement.pathElement(SUBMODEL_NAME, "existing"));
    final ModelNode addChild = Util.createEmptyOperation(ADD, attributePath);
    controller.execute(addChild, null, null, null);

    // should be able to remove it
    final ModelNode op = Util.createEmptyOperation(REMOVE, attributePath);
    ModelNode result = controller.execute(op, null, null, null);

    Assert.assertEquals("success", result.get("outcome").asString());
}
 

@Before
public void setupController() throws InterruptedException {
    System.out.println("=========  New Test \n");

    container = ServiceContainer.Factory.create("test");
    ServiceTarget target = container.subTarget();
    TestModelControllerService svc = new ModelControllerImplUnitTestCase.ModelControllerService();
    target.addService(ServiceName.of("ModelController")).setInstance(svc).install();
    sharedState = svc.getSharedState();
    svc.awaitStartup(30, TimeUnit.SECONDS);
    controller = svc.getValue();
    ModelNode setup = Util.getEmptyOperation("setup", new ModelNode());
    controller.execute(setup, null, null, null);

    assertEquals(ControlledProcessState.State.RUNNING, svc.getCurrentProcessState());
}
 

@Test
public void testInstallSubsystemXmlPlatformPlugins() throws Exception {
  String subsystemXml = FileUtils.readFile(SUBSYSTEM_WITH_PROCESS_ENGINES_ELEMENT_ONLY);

  KernelServices services = createKernelServicesBuilder(null)
      .setSubsystemXml(subsystemXml)
      .build();

  ServiceContainer container = services.getContainer();
  ServiceController<?> serviceController = container.getService(PLATFORM_BPM_PLATFORM_PLUGINS_SERVICE_NAME);
  assertNotNull(serviceController);
  Object platformPlugins = serviceController.getValue();
  assertNotNull(platformPlugins);
  assertTrue(platformPlugins instanceof BpmPlatformPlugins);
  List<BpmPlatformPlugin> plugins = ((BpmPlatformPlugins) platformPlugins).getPlugins();
  assertEquals(1, plugins.size());
  assertTrue(plugins.get(0) instanceof ExampleBpmPlatformPlugin);
}
 

@Test
  public void testInstallSubsystemWithJobExecutorXml() throws Exception {
    String subsystemXml = FileUtils.readFile(SUBSYSTEM_WITH_JOB_EXECUTOR);
//    System.out.println(normalizeXML(subsystemXml));
    KernelServices services = createKernelServicesBuilder(null)
        .setSubsystemXml(subsystemXml)
        .build();
    ServiceContainer container = services.getContainer();
//    container.dumpServices();

    assertNotNull("platform service should be installed", container.getService(PLATFORM_SERVICE_NAME));
    assertNotNull("process engine service should be bound in JNDI", container.getService(processEngineServiceBindingServiceName));

    assertNotNull("platform jobexecutor service should be installed", container.getService(PLATFORM_JOBEXECUTOR_SERVICE_NAME));

  }
 

@BeforeClass
public static void setupController() throws InterruptedException {
    container = ServiceContainer.Factory.create("test");
    ServiceTarget target = container.subTarget();
    PlatformMBeanTestModelControllerService svc = new PlatformMBeanTestModelControllerService();
    ServiceBuilder<ModelController> builder = target.addService(ServiceName.of("ModelController"), svc);
    builder.install();
    svc.latch.await(30, TimeUnit.SECONDS);
    controller = svc.getValue();
    ModelNode setup = Util.getEmptyOperation("setup", new ModelNode());
    controller.execute(setup, null, null, null);

    client = controller.createClient(Executors.newSingleThreadExecutor());
}
 

private static SuspendController getSuspendController(ServiceContainer sc) {
    SuspendController result = null;
    if (sc != null && !sc.isShutdownComplete()) {
        final ServiceController serviceController = sc.getService(JBOSS_SUSPEND_CONTROLLER);
        if (serviceController != null && serviceController.getState() == ServiceController.State.UP) {
            result = (SuspendController) serviceController.getValue();
        }
    }
    return result;
}
 

@Test
public void testInstallSubsystemXml() throws Exception {
  String subsystemXml = FileUtils.readFile(SUBSYSTEM_WITH_PROCESS_ENGINES_ELEMENT_ONLY);

  KernelServices services = createKernelServicesBuilder(null)
      .setSubsystemXml(subsystemXml)
      .build();

  ServiceContainer container = services.getContainer();

  assertNotNull("platform service should be installed", container.getService(PLATFORM_SERVICE_NAME));
  assertNotNull("process engine service should be bound in JNDI", container.getService(PROCESS_ENGINE_SERVICE_BINDING_SERVICE_NAME));
  assertNull(container.getService(PLATFORM_JOBEXECUTOR_SERVICE_NAME));
}
 

public LegacyKernelServicesImpl(ServiceContainer container, ModelTestModelControllerService controllerService,
        StringConfigurationPersister persister, ManagementResourceRegistration rootRegistration,
        OperationValidator operationValidator, String mainSubsystemName, ExtensionRegistry extensionRegistry,
        ModelVersion legacyModelVersion, boolean successfulBoot, Throwable bootError, boolean registerTransformers) {
    // FIXME LegacyKernelServicesImpl constructor
    super(container, controllerService, persister, rootRegistration, operationValidator, mainSubsystemName,
            extensionRegistry, legacyModelVersion, successfulBoot, bootError, registerTransformers);
}
 

public LegacyKernelServicesImpl(ServiceContainer container, ModelTestModelControllerService controllerService,
        StringConfigurationPersister persister, ManagementResourceRegistration rootRegistration,
        OperationValidator operationValidator, ModelVersion legacyModelVersion, boolean successfulBoot, Throwable bootError,
        ExtensionRegistry extensionRegistry, ContentRepository contentRepository) {
    // FIXME MainKernelServicesImpl constructor
    super(container, controllerService, persister, rootRegistration, operationValidator, legacyModelVersion, successfulBoot,
            bootError, extensionRegistry);
    this.contentRepository = contentRepository;
}
 

protected ModelTestKernelServicesImpl(ServiceContainer container, ModelTestModelControllerService controllerService, StringConfigurationPersister persister, ManagementResourceRegistration rootRegistration,
        OperationValidator operationValidator, ModelVersion legacyModelVersion, boolean successfulBoot, Throwable bootError) {
    this.container = container;
    this.controllerService = controllerService;
    this.controller = controllerService.getValue();
    this.persister = persister;
    this.operationValidator = operationValidator;
    this.rootRegistration = rootRegistration;
    this.legacyServices = legacyModelVersion != null ? null : new HashMap<ModelVersion, T>();
    this.successfulBoot = successfulBoot;
    this.bootError = bootError;
}
 

protected AbstractKernelServicesImpl(ServiceContainer container, ModelTestModelControllerService controllerService,
                StringConfigurationPersister persister, ManagementResourceRegistration rootRegistration,
                OperationValidator operationValidator, String mainSubsystemName,
                ExtensionRegistry extensionRegistry, ModelVersion legacyModelVersion, boolean successfulBoot,
                Throwable bootError, boolean registerTransformers) {
    super(container, controllerService, persister, rootRegistration, operationValidator, legacyModelVersion, successfulBoot, bootError);

    this.mainSubsystemName = mainSubsystemName;
    this.extensionRegistry = extensionRegistry;
    this.registerTransformers = registerTransformers;
}
 

@Test
public void testInstallSubsystemWithEnginesAndPropertiesXml() throws Exception {
  String subsystemXml = FileUtils.readFile(SUBSYSTEM_WITH_ENGINES_AND_PROPERTIES);

  KernelServices services = createKernelServicesBuilder(null)
      .setSubsystemXml(subsystemXml)
      .build();
  ServiceContainer container = services.getContainer();


  assertNotNull("platform service should be installed", container.getService(PLATFORM_SERVICE_NAME));
  assertNotNull("process engine service should be bound in JNDI", container.getService(processEngineServiceBindingServiceName));

  ServiceController<?> defaultEngineService = container.getService(ServiceNames.forManagedProcessEngine("__default"));

  assertNotNull("process engine controller for engine __default is installed ", defaultEngineService);

  ManagedProcessEngineMetadata metadata = ((MscManagedProcessEngineController) defaultEngineService.getService()).getProcessEngineMetadata();
  Map<String, String> configurationProperties = metadata.getConfigurationProperties();
  assertEquals("default", configurationProperties.get("job-name"));
  assertEquals("default", configurationProperties.get("job-acquisition"));
  assertEquals("default", configurationProperties.get("job-acquisition-name"));

  Map<String, String> foxLegacyProperties = metadata.getFoxLegacyProperties();
  assertTrue(foxLegacyProperties.isEmpty());

  assertNotNull("process engine controller for engine __test is installed ", container.getService(ServiceNames.forManagedProcessEngine("__test")));
  assertNotNull("process engine controller for engine __emptyPropertiesTag is installed ", container.getService(ServiceNames.forManagedProcessEngine("__emptyPropertiesTag")));
  assertNotNull("process engine controller for engine __noPropertiesTag is installed ", container.getService(ServiceNames.forManagedProcessEngine("__noPropertiesTag")));
}
 

@Override
public void asyncCancel(final boolean interruptionDesired) {
    container.shutdown();
    container.addTerminateListener(new ServiceContainer.TerminateListener() {
        @Override
        public void handleTermination(final Info info) {
            setCancelled();
        }
    });
}
 

@Override
@SuppressWarnings("unchecked")
public AsyncFuture<ServiceContainer> startup(Configuration configuration, List<ServiceActivator> extraServices) {
    try {
        ServiceContainer container = bootstrap(configuration, extraServices).get();
        ServiceController<?> controller = container.getRequiredService(Services.JBOSS_AS);
        return (AsyncFuture<ServiceContainer>) controller.getValue();
    } catch (Exception ex) {
        shutdownHook.shutdown(true);
        throw ServerLogger.ROOT_LOGGER.cannotStartServer(ex);
    }
}
 

@Test
  public void testJobAcquisitionStrategyOptional() throws Exception {
    String subsystemXml = FileUtils.readFile(SUBSYSTEM_WITH_JOB_EXECUTOR_WITHOUT_ACQUISITION_STRATEGY);
//    System.out.println(normalizeXML(subsystemXml));
    KernelServices services = createKernelServicesBuilder(null)
        .setSubsystemXml(subsystemXml)
        .build();
    ServiceContainer container = services.getContainer();
//    container.dumpServices();

    assertNotNull("platform service should be installed", container.getService(PLATFORM_SERVICE_NAME));
    assertNotNull("process engine service should be bound in JNDI", container.getService(processEngineServiceBindingServiceName));

    assertNotNull("platform jobexecutor service should be installed", container.getService(PLATFORM_JOBEXECUTOR_SERVICE_NAME));
  }
 

public void stop() throws Exception {
    this.container.stop();
    awaitContainerTermination();
    this.containerStarted = false;

    //Clear the container ShutdownHook so it doesn't try to execute after container is stopped
    Field field = this.container.getClass().getDeclaredField("serviceContainer");
    field.setAccessible(true);
    ServiceContainer serviceContainer = (ServiceContainer) field.get(this.container);

    Class<?> shutdownHookHolder = null;
    Class<?>[] declaredClasses = serviceContainer.getClass().getDeclaredClasses();
    for (Class<?> clazz : declaredClasses) {
        if (clazz.getName().contains("ShutdownHookHolder")) {
            shutdownHookHolder = clazz;
        }
    }

    if (shutdownHookHolder != null) {
        Field containersSetField = shutdownHookHolder.getDeclaredField("containers");
        containersSetField.setAccessible(true);
        Set<?> set = (Set<?>) containersSetField.get(null);
        set.clear();
    }

    this.container = null;

    this.client = null;
    this.deployer.get().removeAllContent();
    this.deployer = null;
    cleanup();
}
 

public BootstrapListener(final ServiceContainer serviceContainer, final long startTime, final ServiceTarget serviceTarget, final FutureServiceContainer futureContainer, final String prettyVersion, final File tempDir) {
    this.serviceContainer = serviceContainer;
    this.startTime = startTime;
    this.serviceTarget = serviceTarget;
    this.prettyVersion = prettyVersion;
    this.futureContainer = futureContainer;
    this.tempDir = tempDir;
    serviceTarget.addMonitor(monitor);
}
 

@Test
public void testInstallSubsystemWithJobExecutorXml() throws Exception {
  String subsystemXml = FileUtils.readFile(SUBSYSTEM_WITH_JOB_EXECUTOR);
  KernelServices services = createKernelServicesBuilder(null)
      .setSubsystemXml(subsystemXml)
      .build();
  ServiceContainer container = services.getContainer();

  commonSubsystemServicesAreInstalled(container);
}