protected ModelNode testWrite(
final ModelNode address, final String attribute, final ModelNode value) throws IOException {
final CompositeOperationBuilder builder = CompositeOperationBuilder.create();
builder.addStep(Operations.createWriteAttributeOperation(address, attribute, value));
// Create the read operation
builder.addStep(Operations.createReadAttributeOperation(address, attribute));
final ModelNode result = executeOperation(builder.build());
assertEquals(value, Operations.readResult(Operations.readResult(result).get("step-2")));
return result;
}
static boolean isStandaloneRunning(final ModelControllerClient client) {
try {
final ModelNode response =
client.execute(Operations.createReadAttributeOperation(EMPTY_ADDRESS, "server-state"));
if (Operations.isSuccessfulOutcome(response)) {
final String state = Operations.readResult(response).asString();
return !CONTROLLER_PROCESS_STATE_STARTING.equals(state)
&& !CONTROLLER_PROCESS_STATE_STOPPING.equals(state);
}
} catch (RuntimeException | IOException e) {
LOGGER.debug("Interrupted determining if standalone is running", e);
}
return false;
}
static File getAbsoluteLogFilePath(final ManagementClient client, final String filename)
throws IOException, MgmtOperationException {
final ModelNode address =
PathAddress.pathAddress(
PathElement.pathElement(ModelDescriptionConstants.PATH, "jboss.server.log.dir"))
.toModelNode();
final ModelNode op =
Operations.createReadAttributeOperation(address, ModelDescriptionConstants.PATH);
final ModelNode result = client.getControllerClient().execute(op);
if (Operations.isSuccessfulOutcome(result)) {
return new File(Operations.readResult(result).asString(), filename);
}
throw new MgmtOperationException("Failed to read the path resource", op, result);
}
protected ModelNode testUndefine(
final ModelNode address, final String attribute, final boolean expectFailure)
throws IOException {
final CompositeOperationBuilder builder = CompositeOperationBuilder.create();
builder.addStep(Operations.createUndefineAttributeOperation(address, attribute));
// Create the read operation
final ModelNode readOp = Operations.createReadAttributeOperation(address, attribute);
readOp.get("include-defaults").set(false);
builder.addStep(readOp);
final ModelNode result = client.getControllerClient().execute(builder.build());
if (expectFailure) {
assertFalse(
"Undefining attribute " + attribute + " should have failed.",
Operations.isSuccessfulOutcome(result));
} else {
if (!Operations.isSuccessfulOutcome(result)) {
Assert.fail(Operations.getFailureDescription(result).toString());
}
assertFalse(
"Attribute '" + attribute + "' was not undefined.",
Operations.readResult(Operations.readResult(result).get("step-2")).isDefined());
}
return result;
}
private static ModelNode execute(
final ModelControllerClient client, final Operation op, final boolean expectFailure)
throws IOException {
final ModelNode result = client.execute(op);
if (Operations.isSuccessfulOutcome(result)) {
return Operations.readResult(result);
}
if (!expectFailure) {
throw new RuntimeException(
String.format(
"Failed to execute operation: %s%n%s",
op.getOperation(), Operations.getFailureDescription(result)));
}
return Operations.getFailureDescription(result);
}
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);
}
}