Java Util.createOperation方法代码示例

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testReadChildrenResourcesRecursive() throws Exception {
    attributeOutLatch.countDown();

    ModelNode op = Util.createOperation(READ_CHILDREN_RESOURCES_OPERATION, SUBSYSTEM_ADDRESS);
    op.get(CHILD_TYPE).set(PARENT);
    op.get(INCLUDE_RUNTIME).set(true);
    op.get(RECURSIVE).set(true);
    ModelNode result = executeForResult(op);
    assertEquals(result.toString(), ModelType.OBJECT, result.getType());
    assertEquals(result.toString(), 1, result.asInt());
    ModelNode parentResult = result.get(PARENT_ELEMENT.getValue());
    assertTrue(result.toString(), parentResult.hasDefined(CHILD, "C", ATTR));
    assertTrue(result.toString(), parentResult.get(CHILD, "C", ATTR).asInt() == 1);
    assertFalse(result.toString(), parentResult.get(CHILD).has("B"));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private void test(boolean sensitiveResourceVisible, StandardRole... roles) {
    ModelNode operation = Util.createOperation(READ_CHILDREN_NAMES_OPERATION, EMPTY_ADDRESS);
    operation.get(CHILD_TYPE).set(UNCONSTRAINED_RESOURCE);
    ModelNode result = executeWithRoles(operation, roles);

    assertEquals(SUCCESS, result.get(OUTCOME).asString());
    assertTrue(has(FOO, result.get(RESULT)));
    assertTrue(has(BAR, result.get(RESULT)));

    operation.get(CHILD_TYPE).set(SENSITIVE_CONSTRAINED_RESOURCE);
    result = executeWithRoles(operation, roles);
    assertEquals(sensitiveResourceVisible, has(FOO, result.get(RESULT)));
    assertEquals(sensitiveResourceVisible, has(BAR, result.get(RESULT)));

    assertEquals(!sensitiveResourceVisible, result.get(RESPONSE_HEADERS, ACCESS_CONTROL).get(0)
            .get("filtered-children-types").get(0).asString().equals(SENSITIVE_CONSTRAINED_RESOURCE));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testReadAttributeGroup() throws Exception {
    attributeOutLatch.countDown();

    ModelNode op = Util.createOperation(READ_ATTRIBUTE_GROUP_OPERATION, CHILD_B_ADDRESS);
    op.get(NAME).set(GROUP);
    ModelNode rsp = executeCheckForFailure(op);
    //noinspection ThrowableResultOfMethodCallIgnored
    assertTrue(rsp.toString(), rsp.get(FAILURE_DESCRIPTION).asString().contains(ControllerLogger.MGMT_OP_LOGGER.managementResourceNotFound(CHILD_B_ADDRESS).getMessage()));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private ModelNode createWriteAttributeOperation(KernelServices kernelServices, String name, String attrName, ModelNode attrValue) {
    ModelNode operation = Util.createOperation(WRITE_ATTRIBUTE_OPERATION, getPathAddress(name));
    operation.get(NAME).set(attrName);
    operation.get(VALUE).set(attrValue);

    kernelServices.validateOperation(operation);

    return operation;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private void failedReplaceBrokenDeployment() throws IOException, MgmtOperationException {
    ModelNode op = Util.createOperation(FULL_REPLACE_DEPLOYMENT, PathAddress.EMPTY_ADDRESS);
    op.get(NAME).set(BROKEN_DEPLOYMENT);
    ModelNode content = new ModelNode();
    content.get(URL).set(deployment.toURI().toURL().toString());
    op.get(CONTENT).add(content);
    final ModelNode ret = masterClient.execute(op);
    if (! FAILED.equals(ret.get(OUTCOME).asString())) {
        throw new MgmtOperationException("Management operation succeeded.", op, ret);
    }
    // Validate the server results are included
    ModelNode m3Resp = ret.get(SERVER_GROUPS, MSG, HOST, "slave", "main-three", RESPONSE);
    Assert.assertTrue(ret.toString(), m3Resp.isDefined());
    Assert.assertEquals(m3Resp.toString(), FAILED, m3Resp.get(OUTCOME).asString());
    Assert.assertTrue(m3Resp.toString(), m3Resp.get(FAILURE_DESCRIPTION).asString().contains(ServiceActivatorDeployment.FAILURE_MESSAGE));

    ModelNode failDesc = ret.get(FAILURE_DESCRIPTION);
    Assert.assertTrue(failDesc.toString(), failDesc.isDefined());
    ModelNode servers = failDesc.asProperty().getValue();
    Assert.assertTrue(failDesc.toString(), servers.isDefined());
    ModelNode serverFail = servers.get(SERVER_GROUP, MSG, HOST, "slave", "main-three");
    Assert.assertTrue(failDesc.toString(), serverFail.isDefined());
    Assert.assertTrue(failDesc.toString(), serverFail.toString().contains(ServiceActivatorDeployment.FAILURE_MESSAGE));
    String logs = readLogs();
    Assert.assertFalse(logs + " shouldn't contain WFLYCTL0190", logs.contains("WFLYCTL0190"));
    Assert.assertFalse(logs + " shouldn't contain java.util.NoSuchElementException", logs.contains("java.util.NoSuchElementException"));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private void testDataSource(boolean canWrite, ModelControllerClient client) throws IOException {
    ModelNode operation = Util.createOperation(WRITE_ATTRIBUTE_OPERATION, pathAddress(
            pathElement(SUBSYSTEM, "rbac"),
            pathElement("rbac-constrained", "default")
    ));
    operation.get(NAME).set("new-connection-sql");
    operation.get(VALUE).set("java:jboss/datasources/ExampleDS_XXX");
    try {
        RbacUtil.executeOperation(client, operation, canWrite ? Outcome.SUCCESS : Outcome.UNAUTHORIZED);
    } finally {
        operation.get(VALUE).set("java:jboss/datasources/ExampleDS");
        RbacUtil.executeOperation(getManagementClient().getControllerClient(), operation, Outcome.SUCCESS);
    }
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testToggleReadOnly() throws Exception {
    File file = new File(logDir, "test-file.log");
    readFile(file, 1);

    ModelNode op = createAuditLogWriteAttributeOperation(AuditLogLoggerResourceDefinition.LOG_READ_ONLY.getName(), false);
    executeForResult(op);
    List<ModelNode> records = readFile(file, 2);
    List<ModelNode> ops = checkBootRecordHeader(records.get(1), 1, "core", false, false, true);
    checkOpsEqual(op, ops.get(0));

    op = Util.createOperation(READ_RESOURCE_OPERATION, PathAddress.EMPTY_ADDRESS);
    executeForResult(op);
    readFile(file, 2);

    op = createAuditLogWriteAttributeOperation(AuditLogLoggerResourceDefinition.LOG_READ_ONLY.getName(), true);
    executeForResult(op);
    records = readFile(file, 3);
    ops = checkBootRecordHeader(records.get(2), 1, "core", false, false, true);
    checkOpsEqual(op, ops.get(0));

    op = Util.createOperation(READ_RESOURCE_OPERATION, PathAddress.EMPTY_ADDRESS);
    executeForResult(op);
    records = readFile(file, 4);
    ops = checkBootRecordHeader(records.get(3), 1, "core", true, false, true);
    checkOpsEqual(op, ops.get(0));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testRejectTransformersEAP() throws Exception {
    if (modelVersion.getMajor() > 1) {
        return;
    }
    KernelServicesBuilder builder = createKernelServicesBuilder(TestModelType.DOMAIN)
            .setModelInitializer(StandardServerGroupInitializers.XML_MODEL_INITIALIZER, StandardServerGroupInitializers.XML_MODEL_WRITE_SANITIZER)
            .createContentRepositoryContent("12345678901234567890")
            .createContentRepositoryContent("09876543210987654321");

    // Add legacy subsystems
    StandardServerGroupInitializers.addServerGroupInitializers(builder.createLegacyKernelServicesBuilder(modelVersion, testControllerVersion));
    KernelServices mainServices = builder.build();

    PathAddress serverGroupAddress = PathAddress.pathAddress(PathElement.pathElement(SERVER_GROUP));
    List<ModelNode> ops = builder.parseXmlResource("servergroup.xml");
    ModelTestUtils.checkFailedTransformedBootOperations(mainServices, modelVersion, ops, new FailedOperationTransformationConfig()
            .addFailedAttribute(serverGroupAddress,
                    FailedOperationTransformationConfig.ChainedConfig.createBuilder(MANAGEMENT_SUBSYSTEM_ENDPOINT, SOCKET_BINDING_PORT_OFFSET, SOCKET_BINDING_DEFAULT_INTERFACE)
                            .addConfig(new FailedOperationTransformationConfig.RejectExpressionsConfig(MANAGEMENT_SUBSYSTEM_ENDPOINT, SOCKET_BINDING_PORT_OFFSET))
                            .addConfig(new FailedOperationTransformationConfig.NewAttributesConfig(SOCKET_BINDING_DEFAULT_INTERFACE))
                            .build().setReadOnly(MANAGEMENT_SUBSYSTEM_ENDPOINT)));

    //check that we reject /server-group=main-server-group:suspend-servers(timeout=?)
    OperationTransformer.TransformedOperation transOp = mainServices.transformOperation(modelVersion, Util.createOperation("suspend-servers", serverGroupAddress));
    Assert.assertTrue(transOp.getFailureDescription(), transOp.rejectOperation(success()));

    //check that we reject /server-group=main-server-group:resume-servers()
    transOp = mainServices.transformOperation(modelVersion, Util.createOperation("resume-servers", serverGroupAddress));
    Assert.assertNull("operation should have been discarded", transOp.getTransformedOperation());

    // check that we reject new attribute /server-group=main-server-group:stop-servers(blocking=true, timeout=?) (new timeout attribute)
    ModelNode stopServerOp = Util.createOperation("stop-servers", serverGroupAddress);
    stopServerOp.get(TIMEOUT).set(1000);
    transOp = mainServices.transformOperation(modelVersion, stopServerOp);
    Assert.assertTrue(transOp.getFailureDescription(), transOp.rejectOperation(success()));
    stopServerOp.remove(TIMEOUT);
    transOp = mainServices.transformOperation(modelVersion, stopServerOp); //this operation shouldn't be rejected
    Assert.assertFalse(transOp.getFailureDescription(), transOp.rejectOperation(success()));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Before
public void setupLegalFields() throws Exception {
    if (LEGAL_ADDRESS_RESP_FIELDS == null) {
        // See if the server is already sending response headers; if so ignore them when validating responses
        ModelNode operation = Util.createOperation(READ_RESOURCE_OPERATION, PathAddress.EMPTY_ADDRESS);
        ModelNode result = getManagementClient().getControllerClient().execute(operation);
        if (result.has(RESPONSE_HEADERS)) {
            LEGAL_ADDRESS_RESP_FIELDS = new String[]{OUTCOME, RESULT, RESPONSE_HEADERS};
            LEGAL_OPERATION_RESPONSE_FIELDS = new String[]{OUTCOME, FAILURE_DESCRIPTION, ROLLED_BACK, RESPONSE_HEADERS};
        } else {
            LEGAL_ADDRESS_RESP_FIELDS = new String[]{OUTCOME, RESULT};
            LEGAL_OPERATION_RESPONSE_FIELDS = new String[]{OUTCOME, FAILURE_DESCRIPTION, ROLLED_BACK};
        }
    }
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Override
public void execute(OperationContext context, ModelNode operation) throws OperationFailedException {

    final ImmutableManagementResourceRegistration registry = context.getResourceRegistration();
    if (registry == null) {
        throw new OperationFailedException(ControllerLogger.ROOT_LOGGER.noSuchResourceType(context.getCurrentAddress()));
    }
    final Map<String, OperationEntry> operations = registry.getOperationDescriptions(PathAddress.EMPTY_ADDRESS, true);

    final boolean accessControl = ACCESS_CONTROL.resolveModelAttribute(context, operation).asBoolean();

    final ModelNode result = new ModelNode();
    if (operations.size() > 0) {
        final PathAddress address = context.getCurrentAddress();
        for (final Map.Entry<String, OperationEntry> entry : operations.entrySet()) {
            if (isVisible(entry.getValue(), context)) {
                boolean add = true;
                if (accessControl) {
                    ModelNode operationToCheck = Util.createOperation(entry.getKey(), address);
                    operationToCheck.get(OPERATION_HEADERS).set(operation.get(OPERATION_HEADERS));
                    AuthorizationResult authorizationResult = context.authorizeOperation(operationToCheck);
                    add = authorizationResult.getDecision() == Decision.PERMIT;
                }

                if (add) {
                    result.add(entry.getKey());
                } else {
                    context.getResponseHeaders().get(ModelDescriptionConstants.ACCESS_CONTROL, FILTERED_OPERATIONS).add(entry.getKey());
                }
            }
        }
    } else {
        result.setEmptyList();
    }
    context.getResult().set(result);
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private boolean addModelValidationSteps() {
    if (modifiedResourcesForModelValidation == null) {
        return false;
    }
    synchronized (modifiedResourcesForModelValidation) {
        if (modifiedResourcesForModelValidation.size() == 0) {
            return false;
        }
        ModelNode op = Util.createOperation(ValidateModelStepHandler.INTERNAL_MODEL_VALIDATION_NAME, PathAddress.EMPTY_ADDRESS);
        addStep(op, new ValidateModelStepHandler(getManagementModel(), modifiedResourcesForModelValidation,
                extraValidationStepHandler), Stage.MODEL);
        modifiedResourcesForModelValidation.clear();
    }
    return true;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testConfigurationChanges() throws Exception {
    final ModelNode listConfigurationChanges = Util.createOperation("list-changes", ADDRESS);
    List<ModelNode> changes = getManagementClient().executeForResult(listConfigurationChanges).asList();
    assertThat(changes.toString(), changes.size(), is(MAX_HISTORY_SIZE));
    for(ModelNode change : changes) {
        assertThat(change.hasDefined(OPERATION_DATE), is(true));
        assertThat(change.hasDefined(USER_ID), is(false));
        assertThat(change.hasDefined(DOMAIN_UUID), is(false));
        assertThat(change.hasDefined(ACCESS_MECHANISM), is(true));
        assertThat(change.get(ACCESS_MECHANISM).asString(), is("NATIVE"));
        assertThat(change.hasDefined(REMOTE_ADDRESS), is(true));
        assertThat(change.get(OPERATIONS).asList().size(), is(1));
    }

    ModelNode currentChange = changes.get(0);
    ModelNode currentChangeOp = currentChange.get(OPERATIONS).asList().get(0);
    assertThat(currentChangeOp.get(OP).asString(), is(WRITE_ATTRIBUTE_OPERATION));
    assertThat(currentChangeOp.get(OP_ADDR).asString(), is(ALLOWED_ORIGINS_ADDRESS.toModelNode().asString()));
    assertThat(currentChange.get(OUTCOME).asString(), is(FAILED));
    currentChange = changes.get(1);
    currentChangeOp = currentChange.get(OPERATIONS).asList().get(0);
    assertThat(currentChangeOp.get(OP).asString(), is(REMOVE));
    assertThat(currentChangeOp.get(OP_ADDR).asString(), is(SYSTEM_PROPERTY_ADDRESS.toString()));
    assertThat(currentChange.get(OUTCOME).asString(), is(SUCCESS));
    currentChange = changes.get(2);
    currentChangeOp = currentChange.get(OPERATIONS).asList().get(0);
    assertThat(currentChangeOp.get(OP).asString(), is(UNDEFINE_ATTRIBUTE_OPERATION));
    assertThat(currentChangeOp.get(OP_ADDR).asString(), is(ALLOWED_ORIGINS_ADDRESS.toModelNode().asString()));
    assertThat(currentChange.get(OUTCOME).asString(), is(SUCCESS));
    currentChange = changes.get(3);
    currentChangeOp = currentChange.get(OPERATIONS).asList().get(0);
    assertThat(currentChangeOp.get(OP).asString(), is(ADD));
    assertThat(currentChangeOp.get(OP_ADDR).asString(), is(SYSTEM_PROPERTY_ADDRESS.toModelNode().asString()));
    assertThat(currentChange.get(OUTCOME).asString(), is(SUCCESS));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testModifyBaseRoleOfHostScopedRole() {
    testAddHostScopedRoleWithHosts();

    ModelNode operation = Util.createOperation(WRITE_ATTRIBUTE_OPERATION, pathAddress(
            pathElement(CORE_SERVICE, MANAGEMENT),
            pathElement(ACCESS, AUTHORIZATION),
            pathElement(HOST_SCOPED_ROLE, FOO)
    ));
    operation.get(NAME).set(BASE_ROLE);
    operation.get(VALUE).set(OPERATOR);
    ModelNode result = execute(operation);
    checkOutcome(result);

    operation = Util.createOperation(READ_RESOURCE_OPERATION, pathAddress(
            pathElement(CORE_SERVICE, MANAGEMENT),
            pathElement(ACCESS, AUTHORIZATION),
            pathElement(HOST_SCOPED_ROLE, FOO)
    ));
    operation.get(RECURSIVE).set(true);
    result = execute(operation);
    checkOutcome(result);
    result = result.get(RESULT);

    assertEquals(OPERATOR, result.get(BASE_ROLE).asString());
    assertEquals(2, result.get(HOSTS).asList().size());
    assertEquals(SOME_HOST, result.get(HOSTS).get(0).asString());
    assertEquals(ANOTHER_HOST, result.get(HOSTS).get(1).asString());
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testReadServerGroupScopedRole() {
    assertTrue(kernelServices.isSuccessfulBoot());

    // see domain-all.xml

    ModelNode operation = Util.createOperation(READ_RESOURCE_OPERATION, pathAddress(
            pathElement(CORE_SERVICE, MANAGEMENT),
            pathElement(ACCESS, AUTHORIZATION),
            pathElement(SERVER_GROUP_SCOPED_ROLE, "a")
    ));
    operation.get(RECURSIVE).set(true);
    ModelNode result = execute(operation);
    checkOutcome(result);
    result = result.get(RESULT);

    assertEquals("Deployer", result.get(BASE_ROLE).asString());
    assertEquals(2, result.get(SERVER_GROUPS).asList().size());
    assertEquals("main-server-group", result.get(SERVER_GROUPS).get(0).asString());
    assertEquals("other-server-group", result.get(SERVER_GROUPS).get(1).asString());

    operation = Util.createOperation(READ_RESOURCE_OPERATION, pathAddress(
            pathElement(CORE_SERVICE, MANAGEMENT),
            pathElement(ACCESS, AUTHORIZATION),
            pathElement(SERVER_GROUP_SCOPED_ROLE, "b")
    ));
    operation.get(RECURSIVE).set(true);
    result = execute(operation);
    checkOutcome(result);
    result = result.get(RESULT);

    assertEquals("Administrator", result.get(BASE_ROLE).asString());
    assertEquals(1, result.get(SERVER_GROUPS).asList().size());
    assertEquals("other-server-group", result.get(SERVER_GROUPS).get(0).asString());
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private ModelNode createAddOperation(KernelServices kernelServices, String name, String runtimeName, Boolean enabled) throws Exception {
    ModelNode operation = Util.createOperation(DeploymentAddHandler.OPERATION_NAME, getPathAddress(name));
    if (runtimeName != null) {
        operation.get(RUNTIME_NAME).set(runtimeName);
    }
    if (enabled != null) {
        operation.get(ENABLED).set(enabled);
    }
    operation.get(CONTENT);

    kernelServices.validateOperation(operation);

    return operation;
}