コード例 #1
0
  @BeforeClass
  public static void startServer() throws Exception {

    EmbeddedServerFactory.setupCleanDirectories(System.getProperties());

    ServerEnvironment serverEnvironment =
        Main.determineEnvironment(
            new String[0], new Properties(System.getProperties()), System.getenv());
    Assert.assertNotNull(serverEnvironment);
    final Bootstrap bootstrap = Bootstrap.Factory.newInstance();
    final Bootstrap.Configuration configuration = new Bootstrap.Configuration();
    configuration.setServerEnvironment(serverEnvironment);
    configuration.setModuleLoader(Module.getBootModuleLoader());
    configuration.setPortOffset(0);

    container = bootstrap.startup(configuration, Collections.<ServiceActivator>emptyList()).get();
    Assert.assertNotNull(container);
  }
コード例 #2
0
  public static StandaloneServer create(
      final File jbossHomeDir,
      final Properties systemProps,
      final Map<String, String> systemEnv,
      String... systemPackages)
      throws Throwable {

    if (jbossHomeDir == null || jbossHomeDir.isDirectory() == false)
      throw new IllegalStateException("Invalid jboss.home.dir: " + jbossHomeDir);

    if (systemProps.getProperty(ServerEnvironment.HOME_DIR) == null)
      systemProps.setProperty(ServerEnvironment.HOME_DIR, jbossHomeDir.getAbsolutePath());

    setupCleanDirectories(jbossHomeDir, systemProps);

    File modulesDir = new File(jbossHomeDir + "/modules");
    final ModuleLoader moduleLoader =
        InitialModuleLoaderFactory.getModuleLoader(modulesDir, systemPackages);

    // Initialize the Logging system
    ModuleIdentifier logModuleId = ModuleIdentifier.create("org.jboss.logmanager");
    ModuleClassLoader logModuleClassLoader = moduleLoader.loadModule(logModuleId).getClassLoader();
    ClassLoader ctxClassLoader = Thread.currentThread().getContextClassLoader();
    try {
      Thread.currentThread().setContextClassLoader(logModuleClassLoader);
      systemProps.setProperty("java.util.logging.manager", "org.jboss.logmanager.LogManager");
      if (LogManager.getLogManager().getClass() == LogManager.class) {
        System.err.println("WARNING: Failed to load the specified logmodule " + logModuleId);
      } else {
        Module.setModuleLogger(new JDKModuleLogger());
      }
    } finally {
      Thread.currentThread().setContextClassLoader(ctxClassLoader);
    }

    // Load the server Module and get its ClassLoader
    final ModuleIdentifier serverModuleId = ModuleIdentifier.create("org.jboss.as.server");
    final Module serverModule = moduleLoader.loadModule(serverModuleId);
    final ModuleClassLoader serverModuleClassLoader = serverModule.getClassLoader();

    StandaloneServer standaloneServer =
        new StandaloneServer() {

          private Object serviceContainer;

          @Override
          public void start() throws ServerStartException {
            try {
              // Determine the ServerEnvironment
              Class<?> serverMainClass = serverModuleClassLoader.loadClass(Main.class.getName());
              Method determineEnvironmentMethod =
                  serverMainClass.getMethod(
                      "determineEnvironment", String[].class, Properties.class, Map.class);
              Object serverEnvironment =
                  determineEnvironmentMethod.invoke(null, new String[0], systemProps, systemEnv);

              Class<?> bootstrapFactoryClass =
                  serverModuleClassLoader.loadClass(Bootstrap.Factory.class.getName());
              Method newInstanceMethod = bootstrapFactoryClass.getMethod("newInstance");
              Object bootstrap = newInstanceMethod.invoke(null);

              Class<?> configurationClass =
                  serverModuleClassLoader.loadClass(Bootstrap.Configuration.class.getName());
              Constructor<?> configurationCtor = configurationClass.getConstructor();
              Object configuration = configurationCtor.newInstance();

              Method setServerEnvironmentMethod =
                  configurationClass.getMethod(
                      "setServerEnvironment", serverEnvironment.getClass());
              setServerEnvironmentMethod.invoke(configuration, serverEnvironment);

              Method setModuleLoaderMethod =
                  configurationClass.getMethod("setModuleLoader", ModuleLoader.class);
              setModuleLoaderMethod.invoke(configuration, moduleLoader);

              Class<?> bootstrapClass =
                  serverModuleClassLoader.loadClass(Bootstrap.class.getName());
              Method bootstrapStartMethod =
                  bootstrapClass.getMethod("start", configurationClass, List.class);
              Object future =
                  bootstrapStartMethod.invoke(
                      bootstrap, configuration, Collections.<ServiceActivator>emptyList());

              Class<?> asyncFutureClass =
                  serverModuleClassLoader.loadClass(AsyncFuture.class.getName());
              Method getMethod = asyncFutureClass.getMethod("get");
              serviceContainer = getMethod.invoke(future);

            } catch (RuntimeException rte) {
              throw rte;
            } catch (Exception ex) {
              throw new ServerStartException(ex);
            }
          }

          @Override
          public void stop() {
            if (serviceContainer != null) {
              try {
                Class<?> serverContainerClass =
                    serverModuleClassLoader.loadClass(ServiceContainer.class.getName());
                Method shutdownMethod = serverContainerClass.getMethod("shutdown");
                shutdownMethod.invoke(serviceContainer);

                Method awaitTerminationMethod = serverContainerClass.getMethod("awaitTermination");
                awaitTerminationMethod.invoke(serviceContainer);
              } catch (RuntimeException rte) {
                throw rte;
              } catch (Exception ex) {
                ex.printStackTrace();
              }
            }
          }
        };
    return standaloneServer;
  }