static void shutdownDomain(
final DomainClient client, final Map<ServerIdentity, ServerStatus> servers) {
final ModelNode address = new ModelNode().setEmptyList().add("host", "master");
try {
// First shutdown the servers
ModelNode op = Operations.createOperation("stop-servers");
ModelNode response = client.execute(op);
if (Operations.isSuccessfulOutcome(response)) {
op = Operations.createOperation("shutdown", address);
response = client.execute(op);
if (Operations.isSuccessfulOutcome(response)) {
// Wait until the process has died
while (true) {
if (isDomainRunning(client, servers, true)) {
try {
TimeUnit.MILLISECONDS.sleep(20L);
} catch (InterruptedException e) {
LOGGER.debug("Interrupted during sleep", e);
}
} else {
break;
}
}
} else {
LOGGER.debugf("Failed to execute %s: %s", op, Operations.getFailureDescription(response));
}
} else {
LOGGER.debugf("Failed to execute %s: %s", op, Operations.getFailureDescription(response));
}
} catch (IOException e) {
LOGGER.debug("Error shutting down domain", e);
}
}
@Test
@RunAsClient
public void testClient() throws Exception {
ModelControllerClient client =
ModelControllerClient.Factory.create(
"localhost", 9990, new AuthCallbackHandler("bob", "tacos!"));
ModelNode response = client.execute(Operations.createOperation("whoami"));
assertThat(response.get("outcome").asString()).isEqualTo("success");
ModelNode result = response.get("result");
assertThat(result).isNotNull();
assertThat(result.isDefined()).isTrue();
ModelNode identity = result.get("identity");
assertThat(identity).isNotNull();
assertThat(identity.isDefined()).isTrue();
assertThat(identity.get("username").asString()).isEqualTo("bob");
// ===
response =
client.execute(
Operations.createOperation(
"read-resource",
PathAddress.pathAddress(PathElement.pathElement("deployment", "*")).toModelNode()));
assertThat(response.get("outcome").asString()).isEqualTo("success");
result = response.get("result");
assertThat(result).isNotNull();
assertThat(result.isDefined()).isTrue();
assertThat(result.getType()).isEqualTo(ModelType.LIST);
assertThat(result.asList()).hasSize(1);
ModelNode myapp = result.get(0);
assertThat(myapp).isNotNull();
assertThat(myapp.isDefined()).isTrue();
ModelNode myappResult = myapp.get("result");
assertThat(myappResult).isNotNull();
assertThat(myappResult.isDefined()).isTrue();
assertThat(myappResult.get("name").asString()).isEqualTo("myapp.jar");
}
private void testDeployment(final Archive<?> archive) throws IOException {
final ModelControllerClient client = domainMasterLifecycleUtil.getDomainClient();
final ModelNode readServerSubsystems =
Operations.createOperation(
ClientConstants.READ_CHILDREN_NAMES_OPERATION,
Operations.createAddress("host", "master", "server", "main-one"));
readServerSubsystems.get(ClientConstants.CHILD_TYPE).set(ClientConstants.SUBSYSTEM);
final String name = archive.getName();
// Deploy the archive
execute(
client,
createDeployAddOperation(archive.as(ZipExporter.class).exportAsInputStream(), name, null));
Assert.assertTrue("Deployment " + name + " was not deployed.", hasDeployment(client, name));
// Validate the subsystem child names on a server
ModelNode result = execute(client, readServerSubsystems);
validateSubsystemModel("/host=master/server=main-one", result);
// Fully replace the deployment, but with the 'enabled' flag set to false, triggering undeploy
final Operation fullReplaceOp =
createReplaceAndDisableOperation(
archive.as(ZipExporter.class).exportAsInputStream(), name, null);
execute(client, fullReplaceOp);
// Below validates that WFCORE-1577 is fixed, the model should not be missing on the
// /host=master/server=main-one or main-two
// Validate the subsystem child names
result = execute(client, readServerSubsystems);
validateSubsystemModel("/host=master/server=main-one", result);
}
static void shutdownStandalone(final ModelControllerClient client) {
try {
final ModelNode op = Operations.createOperation("shutdown");
final ModelNode response = client.execute(op);
if (Operations.isSuccessfulOutcome(response)) {
while (true) {
if (isStandaloneRunning(client)) {
try {
TimeUnit.MILLISECONDS.sleep(20L);
} catch (InterruptedException e) {
LOGGER.debug("Interrupted during sleep", e);
}
} else {
break;
}
}
} else {
LOGGER.debugf("Failed to execute %s: %s", op, Operations.getFailureDescription(response));
}
} catch (IOException e) {
LOGGER.debug("Interrupted shutting down standalone", e);
}
}
private static boolean hasDeployment(final ModelControllerClient client, final String name)
throws IOException {
final ModelNode op = Operations.createOperation(ClientConstants.READ_CHILDREN_NAMES_OPERATION);
op.get(CHILD_TYPE).set(DEPLOYMENT);
final ModelNode listDeploymentsResult;
try {
listDeploymentsResult = client.execute(op);
// Check to make sure there is an outcome
if (Operations.isSuccessfulOutcome(listDeploymentsResult)) {
final List<ModelNode> deployments = Operations.readResult(listDeploymentsResult).asList();
for (ModelNode deployment : deployments) {
if (name.equals(deployment.asString())) {
return true;
}
}
} else {
throw new IllegalStateException(
Operations.getFailureDescription(listDeploymentsResult).asString());
}
} catch (IOException e) {
throw new IllegalStateException(String.format("Could not execute operation '%s'", op), e);
}
return false;
}
@Test
public void testUsage(@ArquillianResource URL url) throws Exception {
final ManagementClient managementClient = createManagementClient();
final ModelControllerClient client = managementClient.getControllerClient();
try {
// Create the custom formatter
ModelNode op = Operations.createAddOperation(CUSTOM_FORMATTER_ADDRESS);
op.get("class").set("java.util.logging.XMLFormatter");
// the module doesn't really matter since it's a JDK, so we'll just use the jboss-logmanager.
op.get("module").set("org.jboss.logmanager");
executeOperation(client, op);
// Create the handler
op = Operations.createAddOperation(HANDLER_ADDRESS);
final ModelNode file = op.get("file");
file.get("relative-to").set("jboss.server.log.dir");
file.get("path").set(FILE_NAME);
op.get("append").set(false);
op.get("autoflush").set(true);
op.get("named-formatter").set(CUSTOM_FORMATTER_NAME);
executeOperation(client, op);
// Add the handler to the root logger
op = Operations.createOperation("add-handler", ROOT_LOGGER_ADDRESS);
op.get(ModelDescriptionConstants.NAME).set(HANDLER_NAME);
executeOperation(client, op);
// Get the log file
op = Operations.createOperation("resolve-path", HANDLER_ADDRESS);
ModelNode result = executeOperation(client, op);
final Path logFile = Paths.get(readResultAsString(result));
// The file should exist
Assert.assertTrue("The log file was not created.", Files.exists(logFile));
// Log 5 records
doLog(url, "Test message: ", 5);
// Read the log file
try (BufferedReader reader = Files.newBufferedReader(logFile, StandardCharsets.UTF_8)) {
final Pattern pattern = Pattern.compile("^(<message>)+(Test message: \\d)+(</message>)$");
final List<String> messages = new ArrayList<>(5);
String line;
while ((line = reader.readLine()) != null) {
final String trimmedLine = line.trim();
final Matcher m = pattern.matcher(trimmedLine);
// Very simple xml parsing
if (m.matches()) {
messages.add(m.group(2));
}
}
// Should be 5 messages
Assert.assertEquals(5, messages.size());
// Check each message
int count = 0;
for (String msg : messages) {
Assert.assertEquals("Test message: " + count++, msg);
}
}
// Remove the handler from the root-logger
op = Operations.createOperation("remove-handler", ROOT_LOGGER_ADDRESS);
op.get(ModelDescriptionConstants.NAME).set(HANDLER_NAME);
executeOperation(client, op);
// Remove the custom formatter
op = Operations.createRemoveOperation(CUSTOM_FORMATTER_ADDRESS);
executeOperation(client, op);
// Remove the handler
op = Operations.createRemoveOperation(HANDLER_ADDRESS);
executeOperation(client, op);
// So we don't pollute other, verify the formatter and handler have been removed
op = Operations.createReadAttributeOperation(ROOT_LOGGER_ADDRESS, "handlers");
result = executeOperation(client, op);
// Should be a list type
final List<ModelNode> handlers = Operations.readResult(result).asList();
for (ModelNode handler : handlers) {
Assert.assertNotEquals(CUSTOM_FORMATTER_NAME, handler.asString());
}
verifyRemoved(client, CUSTOM_FORMATTER_ADDRESS);
verifyRemoved(client, HANDLER_ADDRESS);
// Delete the log file
Files.delete(logFile);
// Ensure it's been deleted
Assert.assertFalse(Files.exists(logFile));
} finally {
safeClose(managementClient);
safeClose(client);
}
}