private void readLogFile(ModelNode opNode) throws IOException {

        Operation op = OperationBuilder.create(opNode).build();
        try (OperationResponse response = getModelControllerClient().executeOperation(op, OperationMessageHandler.DISCARD)) {

            ModelNode respNode = response.getResponseNode();
            Assert.assertEquals(respNode.toString(), "success", respNode.get("outcome").asString());
            Assert.assertEquals(respNode.toString(), ModelType.STRING, respNode.get("result").getType());
            String uuid = respNode.get("result").asString();
            List<? extends OperationResponse.StreamEntry> streams = response.getInputStreams();
            Assert.assertEquals(1, streams.size());
            OperationResponse.StreamEntry se = streams.get(0);
            Assert.assertEquals(uuid, se.getUUID());
            readLogStream(se.getStream());
        }

    }
 

/**
 * Deploys the archive to the running server.
 *
 * @param archive the archive to deploy
 * @throws IOException if an error occurs deploying the archive
 */
public static void deploy(final Archive<?> archive, ManagementClient managementClient) throws IOException {
    // Use an operation to allow overriding the runtime name
    final ModelNode address = Operations.createAddress(DEPLOYMENT, archive.getName());
    final ModelNode addOp = createAddOperation(address);
    addOp.get("enabled").set(true);
    // Create the content for the add operation
    final ModelNode contentNode = addOp.get(CONTENT);
    final ModelNode contentItem = contentNode.get(0);
    contentItem.get(ClientConstants.INPUT_STREAM_INDEX).set(0);

    // Create an operation and add the input archive
    final OperationBuilder builder = OperationBuilder.create(addOp);
    builder.addInputStream(archive.as(ZipExporter.class).exportAsInputStream());

    // Deploy the content and check the results
    final ModelNode result = managementClient.getControllerClient().execute(builder.build());
    if (!Operations.isSuccessfulOutcome(result)) {
        Assert.fail(String.format("Failed to deploy %s: %s", archive, Operations.getFailureDescription(result).asString()));
    }
}
 

/**
 * Deploys the archive to the running server.
 *
 * @param archive     the archive to deploy
 * @param runtimeName the runtime name for the deployment
 *
 * @throws IOException if an error occurs deploying the archive
 */
public static void deploy(final Archive<?> archive, final String runtimeName) throws IOException {
    // Use an operation to allow overriding the runtime name
    final ModelNode address = Operations.createAddress(DEPLOYMENT, archive.getName());
    final ModelNode addOp = createAddOperation(address);
    if (runtimeName != null && !archive.getName().equals(runtimeName)) {
        addOp.get(RUNTIME_NAME).set(runtimeName);
    }
    addOp.get("enabled").set(true);
    // Create the content for the add operation
    final ModelNode contentNode = addOp.get(CONTENT);
    final ModelNode contentItem = contentNode.get(0);
    contentItem.get(ClientConstants.INPUT_STREAM_INDEX).set(0);

    // Create an operation and add the input archive
    final OperationBuilder builder = OperationBuilder.create(addOp);
    builder.addInputStream(archive.as(ZipExporter.class).exportAsInputStream());

    // Deploy the content and check the results
    final ModelNode result = client.getControllerClient().execute(builder.build());
    if (!Operations.isSuccessfulOutcome(result)) {
        Assert.fail(String.format("Failed to deploy %s: %s", archive, Operations.getFailureDescription(result).asString()));
    }
}
 

protected void reloadSlave() throws Exception {
    ModelNode op = new ModelNode();
    op.get(OP).set("reload");
    op.get(OP_ADDR).add(HOST, "slave");
    op.get(ADMIN_ONLY).set(false);
    try {
        getDomainSlaveClient().execute(new OperationBuilder(op).build());
    } catch(IOException e) {
        final Throwable cause = e.getCause();
        if (!(cause instanceof ExecutionException) && !(cause instanceof CancellationException)) {
            throw e;
        } // else ignore, this might happen if the channel gets closed before we got the response
    }
    // use testSupport.getDomainSlaveLifecycleUtil().awaitHostController(System.currentTimeMillis());
    // in the subclass waiting to know when the slaveHC is available before continuing.
}
 

private void readLogFile(ModelNode opNode, ModelControllerClient client, boolean forServer) throws IOException {
    Operation op = OperationBuilder.create(opNode).build();
    OperationResponse response = null;
    try {
        response = client.executeOperation(op, OperationMessageHandler.DISCARD);

        ModelNode respNode = response.getResponseNode();
        System.out.println(respNode.toString());
        Assert.assertEquals(respNode.toString(), "success", respNode.get("outcome").asString());
        ModelNode result = respNode.get("result");
        Assert.assertEquals(respNode.toString(), ModelType.STRING, result.getType());
        List<? extends OperationResponse.StreamEntry> streams = response.getInputStreams();
        Assert.assertEquals(1, streams.size());
        processResponseStream(response, result.asString(), forServer, client == masterClient);

    } finally {
        StreamUtils.safeClose(response);
    }

}
 

@Override
void setUpDomain(DomainTestSupport testSupport, DomainClient masterClient, DomainClient slaveClient) throws Exception {
    //Add minimal server
    cloneProfile(masterClient, "minimal", "overlay-affected");
    initialized = 1;
    createServerGroup(masterClient, "overlay-group-affected", "overlay-affected");
    initialized = 2;
    createServer(slaveClient, "server-affected", "overlay-group-affected", portOffset);
    initialized = 3;
    startServer(slaveClient, "server-affected");
    initialized = 4;
    DomainTestUtils.executeForResult(Util.createAddOperation(OVERLAY_ADDRESS), masterClient);
    initialized = 5;
    ModelNode addOverlayContent = Util.createAddOperation(OVERLAY_CONTENT_ADDRESS);
    addOverlayContent.get(CONTENT, INPUT_STREAM_INDEX).set(0);
    OperationBuilder builder = OperationBuilder.create(addOverlayContent);
    builder.addInputStream(new ByteArrayInputStream("initial".getBytes(StandardCharsets.UTF_8)));
    ModelNode result = masterClient.execute(builder.build());
    Assert.assertEquals(result.get(FAILURE_DESCRIPTION).asString(), SUCCESS, result.get(OUTCOME).asString());
    initialized = 6;
    DomainTestUtils.executeForResult(Util.createAddOperation(SERVER_GROUP_OVERLAY_ADDRESS), masterClient);
    initialized = 7;
    DomainTestUtils.executeForResult(Util.createAddOperation(SERVER_GROUP_DEPLOYMENT_ADDRESS), masterClient);
    initialized = 8;
}
 

@Override
protected ModelNode execute(CommandContext ctx, ModelNode request)
        throws IOException {
    ModelNode result;
    if (!unmanaged) {
        OperationBuilder op = new OperationBuilder(request);
        op.addFileAsAttachment(file);
        request.get(Util.CONTENT).get(0).get(Util.INPUT_STREAM_INDEX).set(0);
        try (Operation operation = op.build()) {
            result = ctx.getModelControllerClient().execute(operation);
        }
    } else {
        result = ctx.getModelControllerClient().execute(request);
    }
    return result;
}
 

private OperationResponse execute(ModelNode request, boolean useWaitCursor) throws IOException {

        if(request.get(Util.OPERATION).asString().equals(Util.COMPOSITE) &&
                (!request.get(Util.STEPS).isDefined() || request.get(Util.STEPS).asList().isEmpty())) {
            return OperationResponse.Factory.createSimple(new ModelNode("WARN: no request was sent as there were no server-side operations to execute"));
        }

        try {
            if (useWaitCursor) {
                cliGuiCtx.getMainWindow().setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
            }
            return client.get().executeOperation(OperationBuilder.create(request).build(), OperationMessageHandler.DISCARD);
        } finally {
            if (useWaitCursor) {
                cliGuiCtx.getMainWindow().setCursor(Cursor.getDefaultCursor());
            }
        }
    }
 

/**
 * Execute an operation in the model controller
 *
 * @param operation the operation to execute
 * @param inputStreams Input Streams for the operation
 * @return the whole result of the operation
 */
@Override
public ModelNode executeOperation(ModelNode operation, InputStream...inputStreams) {
    if (inputStreams.length == 0) {
        return executeOperation(operation, OperationTransactionControl.COMMIT);
    } else {
        ExecutorService executor = Executors.newCachedThreadPool();
        try {
            ModelControllerClient client = controller.createClient(executor);
            OperationBuilder builder = OperationBuilder.create(operation);
            for (InputStream in : inputStreams) {
                builder.addInputStream(in);
            }
            Operation op = builder.build();

            try {
                return client.execute(op);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        } finally {
            executor.shutdownNow();
        }
    }
}
 

/**
 * Creates new deployment content based on the stream content. The stream content is copied, stored in-memory and
 * closed.
 *
 * @param content the content to deploy
 *
 * @return the deployment content
 */
static DeploymentContent of(final InputStream content) {
    final ByteArrayInputStream copiedContent = copy(content);
    return new DeploymentContent() {
        @Override
        void addContentToOperation(final OperationBuilder builder, final ModelNode op) {
            copiedContent.reset();
            final ModelNode contentNode = op.get(CONTENT);
            final ModelNode contentItem = contentNode.get(0);
            // The index is 0 based so use the input stream count before adding the input stream
            contentItem.get(ClientConstants.INPUT_STREAM_INDEX).set(builder.getInputStreamCount());
            builder.addInputStream(copiedContent);
        }

        @Override
        public String toString() {
            return String.format("%s(%s)", DeploymentContent.class.getName(), copiedContent);
        }
    };
}
 

/**
 * Creates new deployment content based on the {@linkplain URL URL}. The server will require access to the URL.
 *
 * @param url the URL of the content to deploy
 *
 * @return the deployment content
 */
static DeploymentContent of(final URL url) {
    return new DeploymentContent() {
        @Override
        void addContentToOperation(final OperationBuilder builder, final ModelNode op) {
            final ModelNode contentNode = op.get(CONTENT);
            final ModelNode contentItem = contentNode.get(0);
            contentItem.get("url").set(url.toExternalForm());
        }

        @Override
        String resolvedName() {
            final String path = url.getPath();
            final int index = path.lastIndexOf('/');
            if (index >= 0) {
                return path.substring(index + 1);
            }
            return path;
        }

        @Override
        public String toString() {
            return String.format("%s(%s)", DeploymentContent.class.getName(), url.toExternalForm());
        }
    };
}
 

protected static void applyUpdate(final ModelControllerClient client, ModelNode update, boolean allowFailure) throws IOException {
    ModelNode result = client.execute(new OperationBuilder(update).build());
    if (result.hasDefined("outcome") && (allowFailure || "success".equals(result.get("outcome").asString()))) {
        if (result.hasDefined("result")) {
            LOGGER.trace(result.get("result"));
        }
    } else if (result.hasDefined("failure-description")) {
        throw new RuntimeException(result.get("failure-description").toString());
    } else {
        throw new RuntimeException("Operation not successful; outcome = " + result.get("outcome"));
    }
}
 

public static void applyUpdate(ModelNode update, final ModelControllerClient client) throws Exception {
    ModelNode result = client.execute(new OperationBuilder(update).build());
    if (LOGGER.isDebugEnabled()) {
        LOGGER.info("Client update: " + update);
        LOGGER.info("Client update result: " + result);
    }
    if (result.hasDefined("outcome") && "success".equals(result.get("outcome").asString())) {
        LOGGER.debug("Operation succeeded.");
    } else if (result.hasDefined("failure-description")) {
        throw new RuntimeException(result.get("failure-description").toString());
    } else {
        throw new RuntimeException("Operation not successful; outcome = " + result.get("outcome"));
    }
}
 

protected ModelNode executeAndRollbackOperation(final ModelNode op) throws IOException {

        ModelNode broken = Util.createOperation("read-attribute", PathAddress.EMPTY_ADDRESS);
        broken.get("no-such-attribute").set("fail");

        /*ModelNode addDeploymentOp = createOpNode("deployment=malformedDeployment.war", "add");
        addDeploymentOp.get("content").get(0).get("input-stream-index").set(0);

        DefaultOperationRequestBuilder builder = new DefaultOperationRequestBuilder();
        builder.setOperationName("deploy");
        builder.addNode("deployment", "malformedDeployment.war");


        ModelNode[] steps = new ModelNode[3];
        steps[0] = op;
        steps[1] = addDeploymentOp;
        steps[2] = builder.buildRequest();
        ModelNode compositeOp = ModelUtil.createCompositeNode(steps);

        OperationBuilder ob = new OperationBuilder(compositeOp, true);
        ob.addInputStream(new FileInputStream(getBrokenWar()));*/

        ModelNode[] steps = new ModelNode[2];
        steps[0] = op;
        steps[1] = broken;
        ModelNode compositeOp = ModelUtil.createCompositeNode(steps);
        OperationBuilder ob = new OperationBuilder(compositeOp, true);

        return getModelControllerClient().execute(ob.build());
    }
 

private ModelNode readAttribute(String name, ModelNode address) {
    ModelNode op = new ModelNode();
    op.get("operation").set("read-attribute");
    op.get("address").set(address);
    op.get("name").set(name);
    return executeForResult(new OperationBuilder(op).build());
}
 

private Operation deployOperation(PathAddress address, File file) throws IOException {
    final ModelNode op = new ModelNode();
    op.get(OP).set(ADD);
    op.get(OP_ADDR).set(address.toModelNode());
    op.get(ENABLED).set(true);
    op.get(CONTENT).add().get(INPUT_STREAM_INDEX).set(0);

    return OperationBuilder.create(op, true)
            .addFileAsAttachment(file)
            .build();
}
 

static void applyUpdate(final ModelControllerClient client, ModelNode update, boolean allowFailure) throws Exception {
    ModelNode result = client.execute(new OperationBuilder(update).build());
    if (result.hasDefined("outcome") && (allowFailure || "success".equals(result.get("outcome").asString()))) {
        if (result.hasDefined("result")) {
            System.out.println(result.get("result"));
        }
    } else if (result.hasDefined("failure-description")) {
        throw new RuntimeException(result.get("failure-description").toString());
    } else {
        throw new RuntimeException("Operation not successful; outcome = " + result.get("outcome"));
    }
}
 

private void authenticationUsersCredentialReferenceClearTextTest(String username, String pwd) throws Exception {
    ModelNode op = new ModelNode();
    op.get(OP).set(ModelDescriptionConstants.ADD);
    op.get(OP_ADDR).add(CORE_SERVICE, MANAGEMENT).add(SECURITY_REALM, "ManagementRealm")
        .add(ModelDescriptionConstants.AUTHENTICATION, ModelDescriptionConstants.USERS)
        .add(ModelDescriptionConstants.USER, username);
    op.get("credential-reference").set(prepareCredentialReference(pwd));
    getClient().execute(new OperationBuilder(op).build());

    reload();
    processWhoamiOperationSuccess(USERNAME_1, pwd);
}
 

private void authenticationUsersCredentialReferenceStoreAliasTest(String storeName, String username, String pwd)
    throws Exception {
    ModelNode op = new ModelNode();
    op.get(OP).set(ModelDescriptionConstants.ADD);
    op.get(OP_ADDR).add(CORE_SERVICE, MANAGEMENT).add(SECURITY_REALM, "ManagementRealm")
        .add(ModelDescriptionConstants.AUTHENTICATION, ModelDescriptionConstants.USERS)
        .add(ModelDescriptionConstants.USER, username);
    op.get("credential-reference").set(prepareCredentialReference(storeName, username));
    getClient().execute(new OperationBuilder(op).build());

    reload();
    processWhoamiOperationSuccess(USERNAME_2, pwd);
}
 

protected void addAliasOperation(ModelNode credentialStoreAddress, String aliasName, String secretValue)
    throws IOException {
    ModelNode op = Operations.createOperation("add-alias", credentialStoreAddress);
    op.get("secret-value").set(secretValue);
    op.get("alias").set(aliasName);
    getClient().execute(new OperationBuilder(op).build());
}
 

/**
 * Creates managed deployment
 *
 * @param name deployment runtime name
 * @param archive archive to deploy
 */
private void deployPersistent(ModelControllerClient client, String name, Archive archive) throws IOException {
    PathAddress address = PathAddress.pathAddress(DEPLOYMENT, name);

    ModelNode operation = Util.createOperation(ADD, address);
    operation.get(CONTENT).get(0).get(INPUT_STREAM_INDEX).set(0);
    OperationBuilder ob = new OperationBuilder(operation, true);
    ob.addInputStream(archive.as(ZipExporter.class).exportAsInputStream());
    ModelNode result = client.execute(ob.build());
    Assert.assertEquals(SUCCESS, result.get(OUTCOME).asString());

    operation = Util.createOperation(DEPLOY, address);
    result = client.execute(operation);
    Assert.assertEquals(SUCCESS, result.get(OUTCOME).asString());
}
 

private void replaceWithPersistent(ModelControllerClient client, String name, Archive archive) throws IOException {
    ModelNode operation = Util.createOperation(FULL_REPLACE_DEPLOYMENT, PathAddress.EMPTY_ADDRESS);
    operation.get(CONTENT).get(0).get(INPUT_STREAM_INDEX).set(0);
    operation.get(ENABLED).set(true);
    operation.get(NAME).set(name);
    OperationBuilder ob = new OperationBuilder(operation, true);
    ob.addInputStream(archive.as(ZipExporter.class).exportAsInputStream());
    ModelNode result = client.execute(ob.build());
    Assert.assertEquals(result.toString(), SUCCESS, result.get(OUTCOME).asString());
}
 

void configureUser(final ModelControllerClient client, final CompositeOperationBuilder compositeOp) throws IOException {

        // Determine the we should be using a security-realm or SASL (we assume SASL means Elytron is enabled)
        String securityRealm = "ManagementRealm";
        ModelNode op = Operations.createReadResourceOperation(Operations.createAddress("core-service", "management", "management-interface", "http-interface"));
        ModelNode result = executeForSuccess(client, OperationBuilder.create(op).build());
        if (result.hasDefined("security-realm")) {
            securityRealm = result.get("security-realm").asString();
        } else if (result.hasDefined("http-upgrade")) {
            final ModelNode httpUpgrade = result.get("http-upgrade");
            // We could query this further to get the actual name of the configurable-sasl-server-factory. Since this
            // is a test we're making some assumptions to limit the number of query calls made to the server.
            if (httpUpgrade.hasDefined("sasl-authentication-factory")) {
                elytronEnabled = true;
            }
        }

        if (elytronEnabled) {
            userAuthAddress = Operations.createAddress("subsystem", "elytron", "configurable-sasl-server-factory", "configured");
            op = Operations.createOperation("map-remove", userAuthAddress);
            op.get("name").set("properties");
            op.get("key").set(DEFAULT_USER_KEY);
            compositeOp.addStep(op.clone());
            op = Operations.createOperation("map-put", userAuthAddress);
            op.get("name").set("properties");
            op.get("key").set(DEFAULT_USER_KEY);
            op.get("value").set("IAmAdmin");
            compositeOp.addStep(op.clone());

            userIdentRealmAddress = Operations.createAddress("subsystem", "elytron", "identity-realm", "local");
            compositeOp.addStep(Operations.createWriteAttributeOperation(userIdentRealmAddress, "identity", "IAmAdmin"));

        } else {
            userAuthAddress = Operations.createAddress(CORE_SERVICE, MANAGEMENT, SECURITY_REALM, securityRealm, AUTHENTICATION, LOCAL);
            compositeOp.addStep(Operations.createWriteAttributeOperation(userAuthAddress, "default-user", "IAmAdmin"));
        }
    }
 

/**
 * prepares a DMR operation for applying a patch
 */
public static Operation createPatchOperation(File patchFile) throws FileNotFoundException {
    final ModelNode patchOperation = new ModelNode();
    patchOperation.get(ModelDescriptionConstants.OP_ADDR).add("core-service", "patching");
    patchOperation.get(ModelDescriptionConstants.OP).set("patch");
    patchOperation.get("content").get(0).get("input-stream-index").set(0);
    return OperationBuilder.create(patchOperation)
            .addInputStream(new FileInputStream(patchFile)).build();
}
 

/**
 * prepares a DMR operation for applying a patch
 */
public static Operation createRollbackOperation(String patchId) throws FileNotFoundException {
    final ModelNode patchOperation = new ModelNode();
    patchOperation.get(ModelDescriptionConstants.OP_ADDR).add("core-service", "patching");
    patchOperation.get(ModelDescriptionConstants.OP).set("rollback");
    patchOperation.get("patch-id").set(patchId);
    patchOperation.get("reset-configuration").set(true);
    return OperationBuilder.create(patchOperation).build();
}
 

private Operation buildDeploymentAddOperation() throws IOException, OperationFormatException {

        ModelNode addDeploymentOp = new ModelNode();
        addDeploymentOp.get(ModelDescriptionConstants.ADDRESS).add(DEPLOYMENT, DEPLOYMENT_NAME);
        addDeploymentOp.get(ModelDescriptionConstants.OP).set(ModelDescriptionConstants.ADD);
        addDeploymentOp.get("content").get(0).get("input-stream-index").set(0);

        OperationBuilder ob = new OperationBuilder(addDeploymentOp, true);
        ob.addInputStream(new FileInputStream(jarFile));

        return ob.build();
    }
 

private Operation buildDeploymentMappingOperation() throws IOException, OperationFormatException {

        ModelNode deployOp = new ModelNode();
        deployOp.get(ModelDescriptionConstants.OP).set(ModelDescriptionConstants.ADD);
        deployOp.get(ModelDescriptionConstants.ADDRESS).add(ModelDescriptionConstants.SERVER_GROUP, "main-server-group");
        deployOp.get(ModelDescriptionConstants.ADDRESS).add(ModelDescriptionConstants.DEPLOYMENT, DEPLOYMENT_NAME);
        deployOp.get(ModelDescriptionConstants.ENABLED).set(true);

        OperationBuilder ob = new OperationBuilder(deployOp, true);
        ob.addInputStream(new FileInputStream(jarFile));

        return ob.build();
    }
 

protected void setSlaveSecret(String value) throws IOException {
    ModelNode op = new ModelNode();
    op.get(OP).set(WRITE_ATTRIBUTE_OPERATION);
    op.get(OP_ADDR).add(HOST, "slave").add(CORE_SERVICE, MANAGEMENT).add(SECURITY_REALM, "ManagementRealm").add(SERVER_IDENTITY, SECRET);
    op.get(NAME).set(VALUE);
    op.get(VALUE).set(value);
    getDomainSlaveClient().execute(new OperationBuilder(op).build());
}
 

private void slaveWithVaultPasswordTest() throws Exception {

        VaultHandler.cleanFilesystem(RESOURCE_LOCATION, true);

        // create new vault
        VaultHandler vaultHandler = new VaultHandler(RESOURCE_LOCATION);

        try {

            // create security attributes
            String attributeName = "value";
            String vaultPasswordString = vaultHandler.addSecuredAttribute(VAULT_BLOCK, attributeName,
                    RIGHT_PASSWORD.toCharArray());

            // create new vault setting in host
            ModelNode op = new ModelNode();
            op.get(OP).set(ADD);
            op.get(OP_ADDR).add(HOST, "slave").add(CORE_SERVICE, VAULT);
            ModelNode vaultOption = op.get(VAULT_OPTIONS);
            vaultOption.get("KEYSTORE_URL").set(vaultHandler.getKeyStore());
            vaultOption.get("KEYSTORE_PASSWORD").set(vaultHandler.getMaskedKeyStorePassword());
            vaultOption.get("KEYSTORE_ALIAS").set(vaultHandler.getAlias());
            vaultOption.get("SALT").set(vaultHandler.getSalt());
            vaultOption.get("ITERATION_COUNT").set(vaultHandler.getIterationCountAsString());
            vaultOption.get("ENC_FILE_DIR").set(vaultHandler.getEncodedVaultFileDirectory());
            domainSlaveClient.execute(new OperationBuilder(op).build());

            setSlaveSecret("${" + vaultPasswordString + "}");

            reloadSlave();

            testSupport.getDomainSlaveLifecycleUtil().awaitHostController(System.currentTimeMillis());
            // Validate that it joined the master
            readHostControllerStatus(domainMasterClient);
        } finally {
            // remove temporary files
            vaultHandler.cleanUp();
        }
    }
 

private void removeServerIdentity() throws IOException {
    ModelNode op = new ModelNode();
    op.get(OP).set(REMOVE);
    op.get(OP_ADDR).add(HOST, "slave").add(CORE_SERVICE, MANAGEMENT).add(SECURITY_REALM, "ManagementRealm")
            .add(SERVER_IDENTITY, SECRET);
    getDomainSlaveClient().execute(new OperationBuilder(op).build());
}