protected AbstractAddSecurityRealmSubElement(Builder builder) {
    this.securityRealmName = builder.securityRealmName;
    this.replaceExisting = builder.replaceExisting;

    securityRealmAddress =
        Address.coreService("management").and("security-realm", securityRealmName);
  }
  private void performRestartOperation(RestartOperation restartOperation)
      throws IOException, InterruptedException, TimeoutException {
    boolean needsToReconnect = false;
    try {
      restartOperation.perform(ops, Address.root());
    } catch (Throwable e) {
      // server went down before we received the response, this can happen
      needsToReconnect = true;
    }

    waitUntilServerIsRunning(needsToReconnect);
  }
 private boolean isRestartOperationRequired(RestartOperation restartOperation) throws IOException {
   return restartOperation.isRequired(
       ops.readAttribute(Address.root(), Constants.SERVER_STATE), false);
 }
 private boolean isServerRunning() throws IOException {
   ModelNodeResult result = ops.readAttribute(Address.root(), Constants.SERVER_STATE);
   result.assertDefinedValue();
   return ServerState.isRunning(result.stringValue());
 }
Пример #5
0
@RunWith(Arquillian.class)
public class AddDataSourceOnlineTest {
  private OnlineManagementClient client;
  private Operations ops;
  private Administration administration;

  private static final String TEST_DATASOURCE_NAME = "creaper-ds";
  private static final Address TEST_DATASOURCE_ADDRESS =
      Address.subsystem("datasources").and("data-source", TEST_DATASOURCE_NAME);
  private static final String VALID_DS_URL = "jdbc:h2:mem:test-creaper;DB_CLOSE_DELAY=-1;";

  @Before
  public void connect() throws IOException {
    client = ManagementClient.online(OnlineOptions.standalone().localDefault().build());
    ops = new Operations(client);
    administration = new Administration(client);
  }

  @After
  public void cleanup()
      throws IOException, CliException, OperationException, TimeoutException, InterruptedException {
    try {
      ops.removeIfExists(TEST_DATASOURCE_ADDRESS);
      administration.reloadIfRequired();
    } finally {
      client.close();
    }
  }

  @Test
  public void addDataSource_commandSuccessful() throws Exception {
    AddDataSource addDataSource =
        new AddDataSource.Builder(TEST_DATASOURCE_NAME)
            .connectionUrl(VALID_DS_URL)
            .jndiName("java:/jboss/datasources/" + TEST_DATASOURCE_NAME)
            .driverName("h2")
            .connectable(false)
            .jta(false)
            .usernameAndPassword("creaper", "creaper")
            .useJavaContext(true)
            .maxPoolSize(666)
            .minPoolSize(0)
            .statisticsEnabled(false)
            .build();
    client.apply(addDataSource);

    assertTrue("The data source should be created", ops.exists(TEST_DATASOURCE_ADDRESS));
  }

  @Test
  public void addDataSource_replaceExisting() throws Exception {
    client.apply(
        new AddDataSource.Builder(TEST_DATASOURCE_NAME)
            .connectionUrl(VALID_DS_URL)
            .jndiName("java:/jboss/datasources/" + TEST_DATASOURCE_NAME)
            .driverName("h2")
            .usernameAndPassword("creaper", "creaper")
            .build());
    assertTrue("The datasource should be created", ops.exists(TEST_DATASOURCE_ADDRESS));

    client.apply(
        new AddDataSource.Builder(TEST_DATASOURCE_NAME)
            .connectionUrl(VALID_DS_URL)
            .jndiName("java:/jboss/datasources/" + TEST_DATASOURCE_NAME)
            .driverName("h2")
            .usernameAndPassword("creaper2", "creaper2")
            .replaceExisting()
            .build());
    assertTrue("The datasource should be created", ops.exists(TEST_DATASOURCE_ADDRESS));
    assertEquals(
        "The datasource should be replaced with the new one with different username",
        "creaper2",
        ops.readAttribute(TEST_DATASOURCE_ADDRESS, "user-name").stringValue());
  }

  @Test(expected = CommandFailedException.class)
  public void addDataSource_commandFails() throws Exception {
    AddDataSource addDataSource =
        new AddDataSource.Builder(TEST_DATASOURCE_NAME)
            .jndiName("invalid-jndi-name")
            .driverName("h2")
            .connectionUrl("invalid-url")
            .build();
    client.apply(addDataSource);
  }

  @Test
  public void addDataSourceAndEnable_commandSuccessful() throws Exception {
    AddDataSource addDataSource =
        new AddDataSource.Builder(TEST_DATASOURCE_NAME)
            .connectionUrl(VALID_DS_URL)
            .jndiName("java:/jboss/datasources/" + TEST_DATASOURCE_NAME)
            .driverName("h2")
            .enableAfterCreate()
            .connectable(false)
            .jta(false)
            .usernameAndPassword("creaper", "creaper")
            .useJavaContext(true)
            .build();
    client.apply(addDataSource);

    assertTrue("The data source should be created", ops.exists(TEST_DATASOURCE_ADDRESS));
    assertTrue(
        "The data source should be enabled",
        ops.readAttribute(TEST_DATASOURCE_ADDRESS, "enabled").booleanValue());
  }

  @Test
  public void addDataSourceAndEnable_commandFailed_incorrectPoolSize() throws Exception {
    try {
      AddDataSource addDataSource =
          new AddDataSource.Builder(TEST_DATASOURCE_NAME)
              .connectionUrl(VALID_DS_URL)
              .jndiName("java:/jboss/datasources/" + TEST_DATASOURCE_NAME)
              .driverName("h2")
              .maxPoolSize(-1) // improper value which causes enable to fail
              .enableAfterCreate()
              .build();
      client.apply(addDataSource);
      fail("Command should fail");
    } catch (IllegalArgumentException expected) {
      assertFalse(
          "The datasource shouldn't be created as the command should be composite and enable should fail",
          ops.exists(TEST_DATASOURCE_ADDRESS));
    }
  }

  @Test(expected = IllegalArgumentException.class)
  public void addDataSource_commandFailed_urlNotDefined() throws Exception {
    AddDataSource addDataSource =
        new AddDataSource.Builder(TEST_DATASOURCE_NAME)
            .jndiName("java:/jboss/datasources/" + TEST_DATASOURCE_NAME)
            .driverName("h2")
            .maxPoolSize(1)
            .usernameAndPassword("creaper", "creaper")
            .securityDomain("other")
            .build();
    client.apply(addDataSource);
  }

  @Test(expected = IllegalArgumentException.class)
  public void addDataSource_commandFailed_usernameAndSecurityDomainDefined() throws Exception {
    AddDataSource addDataSource =
        new AddDataSource.Builder(TEST_DATASOURCE_NAME)
            .jndiName("java:/jboss/datasources/" + TEST_DATASOURCE_NAME)
            .driverName("h2")
            .build();
    client.apply(addDataSource);
  }

  @Test
  public void addDataSource_commandSuccessful_fullLoad() throws Exception {
    AddDataSource addDataSource =
        new AddDataSource.Builder(TEST_DATASOURCE_NAME)
            .connectionUrl(VALID_DS_URL)
            .jndiName("java:/jboss/datasources/" + TEST_DATASOURCE_NAME)
            .driverName("h2")
            .usernameAndPassword("creaper", "creaper")
            .allocationRetry(3)
            .allocationRetryWaitMillis(1000)
            .allowMultipleUsers(true)
            .backgroundValidation(true)
            .backgroundValidationMillis(1000)
            .blockingTimeoutWaitMillis(1000)
            .checkValidConnectionSql("SELECT 1")
            .connectable(true)
            .addConnectionProperty("other-user-name", "right-its-other-username")
            .datasourceClass("org.h2.jdbcx.JdbcDataSource")
            .driverClass("org.h2.Driver")
            .exceptionSorterClass(
                "org.jboss.jca.adapters.jdbc.extensions.novendor.NullExceptionSorter")
            .addExceptionSorterProperty("exception-sorter-prop", "ok")
            .idleTimeoutMinutes(10)
            .jta(true)
            .managedConnectionPool(
                "org.jboss.jca.core.connectionmanager.pool.mcp.SemaphoreConcurrentLinkedDequeManagedConnectionPool")
            .maxPoolSize(1)
            .minPoolSize(1)
            .newConnectionSql("SELECT 1")
            .flushStrategy(PoolFlushStrategy.ENTIRE_POOL)
            .prefill(true)
            .preparedStatementsCacheSize(3)
            .queryTimeout(20)
            // .reauthPluginClass() - no null reauth plugin exists
            // .securityDomain("other") - can't be used as interferes with usage of username
            .setTxQueryTimeout(true)
            .sharePreparedStatements(true)
            .spy(true)
            .staleConnectionCheckerClass(
                "org.jboss.jca.adapters.jdbc.extensions.novendor.NullStaleConnectionChecker")
            .addStaleConnectionCheckerProperty("stale-checker-prop", "ok")
            .statisticsEnabled(true)
            .trackPreparedStatements(TrackStatementType.TRUE)
            .transactionIsolation(TransactionIsolation.TRANSACTION_REPEATABLE_READ)
            .urlDelimiter(";")
            // .urlSelectorStrategyClass() - can't find any implementation of SPI
            .useCcm(true)
            .useFastFailAllocation(false)
            .useJavaContext(true)
            .useStrictMinPoolSize(true)
            .useTryLock(60)
            .validateOnMatch(true)
            .validConnectionCheckerClass(
                "org.jboss.jca.adapters.jdbc.extensions.novendor.NullValidConnectionChecker")
            .addValidConnectionCheckerProperty("valid-checker-prop", "ok")
            .build();

    client.apply(addDataSource);

    assertTrue("The datasource should be created", ops.exists(TEST_DATASOURCE_ADDRESS));
  }
}
@RunWith(Arquillian.class)
public class AddSecurityRealmOnlineTest {

  private OnlineManagementClient client;
  private Operations ops;
  private Administration administration;

  private static final String TEST_SECURITY_REALM_NAME = "creaperSecRealm";
  private static final Address TEST_SECURITY_REALM_ADDRESS =
      Address.coreService("management").and("security-realm", TEST_SECURITY_REALM_NAME);

  @Before
  public void connect() throws IOException {
    client = ManagementClient.online(OnlineOptions.standalone().localDefault().build());
    ops = new Operations(client);
    administration = new Administration(client);
  }

  @After
  public void cleanup()
      throws IOException, CliException, OperationException, TimeoutException, InterruptedException {
    try {
      ops.removeIfExists(TEST_SECURITY_REALM_ADDRESS);
      administration.reloadIfRequired();
    } finally {
      client.close();
    }
  }

  @Test
  public void addSimple() throws Exception {
    AddSecurityRealm addSecurityRealm =
        new AddSecurityRealm.Builder(TEST_SECURITY_REALM_NAME).build();

    assertFalse("The security realm should not exist", ops.exists(TEST_SECURITY_REALM_ADDRESS));
    client.apply(addSecurityRealm);
    assertTrue("The security realm should be created", ops.exists(TEST_SECURITY_REALM_ADDRESS));
  }

  @Test
  public void addFull() throws Exception {
    AddSecurityRealm addSecurityRealm =
        new AddSecurityRealm.Builder(TEST_SECURITY_REALM_NAME).mapGroupsToRoles(true).build();
    client.apply(addSecurityRealm);

    assertTrue("The security realm should be created", ops.exists(TEST_SECURITY_REALM_ADDRESS));

    ModelNodeResult readAttribute =
        ops.readAttribute(TEST_SECURITY_REALM_ADDRESS, "map-groups-to-roles");
    readAttribute.assertSuccess("Read operation for map-groups-to-roles failed");
    Assert.assertEquals(
        "Read operation for map-groups-to-roles return wrong value",
        "true",
        readAttribute.stringValue());
  }

  @Test(expected = CommandFailedException.class)
  public void existing() throws Exception {
    AddSecurityRealm addSecurityRealm =
        new AddSecurityRealm.Builder(TEST_SECURITY_REALM_NAME).build();
    AddSecurityRealm addSecurityRealm2 =
        new AddSecurityRealm.Builder(TEST_SECURITY_REALM_NAME).mapGroupsToRoles(true).build();

    client.apply(addSecurityRealm);
    client.apply(addSecurityRealm2);

    fail(
        "Security realm creaperSecRealm already exists in configuration, exception should be thrown");
  }

  @Test
  public void overrideExisting() throws Exception {
    AddSecurityRealm addSecurityRealm =
        new AddSecurityRealm.Builder(TEST_SECURITY_REALM_NAME).build();
    AddSecurityRealm addSecurityRealm2 =
        new AddSecurityRealm.Builder(TEST_SECURITY_REALM_NAME)
            .mapGroupsToRoles(true)
            .replaceExisting()
            .build();

    client.apply(addSecurityRealm);
    assertTrue("The security realm should be created", ops.exists(TEST_SECURITY_REALM_ADDRESS));
    client.apply(addSecurityRealm2);
    assertTrue("The security realm should be created", ops.exists(TEST_SECURITY_REALM_ADDRESS));

    ModelNodeResult readAttribute =
        ops.readAttribute(TEST_SECURITY_REALM_ADDRESS, "map-groups-to-roles");
    readAttribute.assertSuccess("Read operation for map-groups-to-roles failed");
    Assert.assertEquals(
        "Read operation for map-groups-to-roles return wrong value",
        "true",
        readAttribute.stringValue());
  }

  @Test(expected = IllegalArgumentException.class)
  public void addSecurityRealm_nullName() throws Exception {
    new AddSecurityRealm.Builder(null).build();
    fail("Creating command with null security realm name should throw exception");
  }

  @Test(expected = IllegalArgumentException.class)
  public void addSecurityRealm_emptyName() throws Exception {
    new AddSecurityRealm.Builder("").build();
    fail("Creating command with empty security realm name should throw exception");
  }
}