Java Util.getWriteAttributeOperation方法代码示例

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

    KernelServices kernelServices = createKernelServicesBuilder(TestModelType.DOMAIN)
            .setXmlResource("domain.xml")
            .build();
    Assert.assertTrue(kernelServices.isSuccessfulBoot());

    PathAddress addr = PathAddress.pathAddress(PROFILE, "testA");
    ModelNode list = new ModelNode().add("bad-profile");
    ModelNode op = Util.getWriteAttributeOperation(addr, INCLUDES, list);
    ModelNode response = kernelServices.executeOperation(op);
    Assert.assertEquals(response.toString(), FAILED, response.get(OUTCOME).asString());
    Assert.assertTrue(response.toString(), response.get(FAILURE_DESCRIPTION).asString().contains("WFLYCTL0369"));

    ProfileUtils.executeDescribeProfile(kernelServices, "testA");
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
protected void updateOptionsAttribute(OperationContext context, ModelNode operation, String type) {

        final PathAddress operationAddress = PathAddress.pathAddress(operation.get(OP_ADDR));
        final PathAddress discoveryOptionsAddress = operationAddress.subAddress(0, operationAddress.size() - 1);
        final ModelNode discoveryOptions = Resource.Tools.readModel(context.readResourceFromRoot(discoveryOptionsAddress));

        // Get the current list of discovery options and remove the given discovery option
        // from the list to maintain the order
        final ModelNode currentList = discoveryOptions.get(ModelDescriptionConstants.OPTIONS);
        final String name = operationAddress.getLastElement().getValue();

        final ModelNode newList = new ModelNode().setEmptyList();
        for (ModelNode e : currentList.asList()) {
            final Property prop = e.asProperty();
            final String discoveryOptionType = prop.getName();
            final String discoveryOptionName = prop.getValue().get(ModelDescriptionConstants.NAME).asString();
            if (!(discoveryOptionType.equals(type) && discoveryOptionName.equals(name))) {
                newList.add(e);
            }
        }

        final ModelNode writeOp = Util.getWriteAttributeOperation(discoveryOptionsAddress, ModelDescriptionConstants.OPTIONS, newList);
        final OperationStepHandler writeHandler = context.getRootResourceRegistration().getSubModel(discoveryOptionsAddress).getOperationHandler(PathAddress.EMPTY_ADDRESS, WRITE_ATTRIBUTE_OPERATION);
        context.addStep(writeOp, writeHandler, OperationContext.Stage.MODEL);
    }
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
/**
 * Add the operation to add the local host definition.
 */
private ModelNode addLocalHost(final ModelNode address, final List<ModelNode> operationList, final String hostName) {

    String resolvedHost =  hostName != null ? hostName : defaultHostControllerName;

    // All further operations should modify the newly added host so the address passed in is updated.
    address.add(HOST, resolvedHost);

    // Add a step to setup the ManagementResourceRegistrations for the root host resource
    final ModelNode hostAddOp = new ModelNode();
    hostAddOp.get(OP).set(HostAddHandler.OPERATION_NAME);
    hostAddOp.get(OP_ADDR).set(address);
    operationList.add(hostAddOp);

    // Add a step to store the HC name
    ModelNode nameValue = hostName == null ? new ModelNode() : new ModelNode(hostName);
    final ModelNode writeName = Util.getWriteAttributeOperation(address, NAME, nameValue);
    operationList.add(writeName);
    return hostAddOp;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Override
protected ServerMigrationTaskResult updateConfiguration(ModelNode config, S source, SubsystemResource subsystemResource, TaskContext context, TaskEnvironment taskEnvironment) {
    if (config.hasDefined(SERVER, SERVER_NAME, HTTP_LISTENER, httpListenerName) && !config.hasDefined(SERVER, SERVER_NAME, HTTP_LISTENER, httpListenerName, REDIRECT_SOCKET_ATTR_NAME)) {
        final PathAddress pathAddress = subsystemResource.getResourcePathAddress().append(SERVER, SERVER_NAME).append(HTTP_LISTENER, httpListenerName);
        final ModelNode op = Util.getWriteAttributeOperation(pathAddress, REDIRECT_SOCKET_ATTR_NAME, REDIRECT_SOCKET_ATTR_VALUE);
        subsystemResource.getServerConfiguration().executeManagementOperation(op);
        context.getLogger().debugf("Undertow's default HTTP listener '%s' redirect-socket set as 'https'.", httpListenerName);
        return ServerMigrationTaskResult.SUCCESS;
    } else {
        return ServerMigrationTaskResult.SKIPPED;
    }
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testAccessOtherValue() throws Exception {
    //Set up the model
    resourceModel.get("checked").set("test");
    resourceModel.get("other").set("value");

    VisibilityCheckerAndConverter checker = new VisibilityCheckerAndConverter();

    final ResourceTransformationDescriptionBuilder builder = TransformationDescriptionBuilder.Factory.createInstance(PATH);
    builder.getAttributeBuilder()
        .addRejectCheck(checker, "checked")
        .setDiscard(checker, "checked")
        .setValueConverter(checker, "checked")
        .end();
    TransformationDescription.Tools.register(builder.build(), transformersSubRegistration);

    final Resource resource = transformResource();
    Assert.assertNotNull(resource);
    final Resource toto = resource.getChild(PATH);
    Assert.assertNotNull(toto);
    final ModelNode model = toto.getModel();
    //The rejection does not trigger for resource transformation
    Assert.assertTrue(model.hasDefined("checked"));
    checker.checkValues("value");

    checker.reset();
    ModelNode add = Util.createAddOperation(PathAddress.pathAddress(PATH));
    add.get("checked").set("test");
    add.get("other").set("value");
    OperationTransformer.TransformedOperation transformedAdd = transformOperation(add);
    Assert.assertFalse(transformedAdd.rejectOperation(success()));
    checker.checkValues("value");

    checker.reset();
    ModelNode write = Util.getWriteAttributeOperation(PathAddress.pathAddress(PATH), "checked", new ModelNode("test"));
    OperationTransformer.TransformedOperation transformedWrite = transformOperation(write);
    Assert.assertFalse(transformedWrite.rejectOperation(success()));
    checker.checkValues("value");
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Before
public void createConfigurationChanges() throws Exception {
    ManagementInterface client = getClientForUser(SUPERUSER_USER);
    final ModelNode add = Util.createAddOperation(PathAddress.pathAddress(ADDRESS));
    add.get("max-history").set(MAX_HISTORY_SIZE);
    client.execute(add);
    ModelNode configureSensitivity = Util.getWriteAttributeOperation(SYSTEM_PROPERTY_CLASSIFICATION_ADDRESS, CONFIGURED_REQUIRES_ADDRESSABLE, true);
    client.execute(configureSensitivity);
    ModelNode setAllowedOrigins = Util.createEmptyOperation("list-add", ALLOWED_ORIGINS_ADDRESS);
    setAllowedOrigins.get(NAME).set(ALLOWED_ORIGINS);
    setAllowedOrigins.get(VALUE).set( "http://www.wildfly.org");
    client.execute(setAllowedOrigins);
    ModelNode disableLogBoot = Util.getWriteAttributeOperation(AUDIT_LOG_ADDRESS, LOG_BOOT, false);
    client.execute(disableLogBoot);
    //read
    client.execute(Util.getReadAttributeOperation(ALLOWED_ORIGINS_ADDRESS, ALLOWED_ORIGINS));
    //invalid operation
    client.execute(Util.getUndefineAttributeOperation(ALLOWED_ORIGINS_ADDRESS, "not-exists-attribute"));
    //invalid operation
    client.execute(Util.getWriteAttributeOperation(ALLOWED_ORIGINS_ADDRESS, "not-exists-attribute", "123456"));
    //write operation, failed
    ModelNode setAllowedOriginsFails = Util.getWriteAttributeOperation(ALLOWED_ORIGINS_ADDRESS, ALLOWED_ORIGINS, "123456");//wrong type, expected is LIST, op list-add
    client.execute(setAllowedOriginsFails);
    ModelNode setSystemProperty = Util.createAddOperation(SYSTEM_PROPERTY_ADDRESS);
    setSystemProperty.get(VALUE).set("changeConfig");
    client.execute(setSystemProperty);
    ModelNode unsetAllowedOrigins = Util.getUndefineAttributeOperation(ALLOWED_ORIGINS_ADDRESS, ALLOWED_ORIGINS);
    client.execute(unsetAllowedOrigins);
    ModelNode enableLogBoot = Util.getWriteAttributeOperation(AUDIT_LOG_ADDRESS, LOG_BOOT, true);
    client.execute(enableLogBoot);
    ModelNode unsetSystemProperty = Util.createRemoveOperation(SYSTEM_PROPERTY_ADDRESS);
    client.execute(unsetSystemProperty);
    ModelNode addInMemoryHandler = Util.createAddOperation(IN_MEMORY_HANDLER_ADDRESS);
    client.execute(addInMemoryHandler);
    ModelNode editInMemoryHandler = Util.getWriteAttributeOperation(IN_MEMORY_HANDLER_ADDRESS, MAX_HISTORY, 50);
    client.execute(editInMemoryHandler);
    ModelNode removeInMemoryHandler = Util.createRemoveOperation(IN_MEMORY_HANDLER_ADDRESS);
    client.execute(removeInMemoryHandler);
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testEmptyProfileIncludesSameSubsystems() throws Exception {
    try {
        //Here we test changing the includes attribute value
        //Testing what happens when adding subsystems at runtime becomes a bit too hard to mock up
        //so we test that in ServerManagementTestCase
        PathAddress addr = getProfileAddress("profile-five");
        ModelNode list = new ModelNode().add("profile-three").add("profile-four");
        ModelNode op = Util.getWriteAttributeOperation(addr, INCLUDES, list);
        MockOperationContext operationContext = getOperationContextForSubsystemIncludes(addr, new RootResourceInitializer() {
            @Override
            public void addAdditionalResources(Resource root) {
                Resource subsystemA = Resource.Factory.create();
                root.getChild(PathElement.pathElement(PROFILE, "profile-three"))
                        .registerChild(PathElement.pathElement(SUBSYSTEM, "a"), subsystemA);

                Resource subsystemB = Resource.Factory.create();
                Resource profile4 = root.getChild(PathElement.pathElement(PROFILE, "profile-four"));
                profile4.registerChild(PathElement.pathElement(SUBSYSTEM, "a"), subsystemB);

                //profile-four is empty
            }
        });
        ProfileResourceDefinition.createIncludesValidationHandler().execute(operationContext, op);
        operationContext.executeNextStep();
        Assert.fail("Expected error");
    } catch (OperationFailedException expected) {
        Assert.assertTrue(expected.getMessage().contains("167"));
        Assert.assertTrue(expected.getMessage().contains("'profile-five'"));
        Assert.assertTrue(expected.getMessage().contains("'profile-four'"));
        Assert.assertTrue(expected.getMessage().contains("'profile-three'"));
        Assert.assertTrue(expected.getMessage().contains("'a'"));
    }
}
 

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

    KernelServices kernelServices = createKernelServices("servergroup.xml");

    PathAddress pa = PathAddress.pathAddress(SERVER_GROUP, "test");
    ModelNode op = Util.getWriteAttributeOperation(pa, PROFILE, "does-not-exist");
    ModelNode response = kernelServices.executeOperation(op);
    Assert.assertEquals(response.toString(), FAILED, response.get(OUTCOME).asString());
    Assert.assertTrue(response.toString(), response.get(FAILURE_DESCRIPTION).asString().contains("WFLYCTL0369"));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test(expected=OperationFailedException.class)
public void testCyclicProfileIncludesWrite() throws Exception {
    PathAddress addr = getProfileAddress("profile-three");
    ModelNode list = new ModelNode().add("profile-four");
    ModelNode op = Util.getWriteAttributeOperation(addr, INCLUDES, list);
    MockOperationContext operationContext = getOperationContextWithIncludes(addr);
    ProfileResourceDefinition.createIncludesValidationHandler().execute(operationContext, op);
    operationContext.executeNextStep();
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private void addManagementAuthorization(ModelNodeList updates) {
    ModelNode domainConfig = domainModel.get(CORE_SERVICE, MANAGEMENT, ACCESS, AUTHORIZATION);
    if (domainConfig.isDefined()) {
        ModelNode baseAddress = new ModelNode();
        baseAddress.add(CORE_SERVICE, MANAGEMENT);
        baseAddress.add(ACCESS, AUTHORIZATION);

        if (domainConfig.hasDefined(PROVIDER)) {
            ModelNode providerOp = Util.getWriteAttributeOperation(baseAddress, PROVIDER, domainConfig.get(PROVIDER));
            updates.add(providerOp);
        }

        addRoleMappings(domainConfig, baseAddress, updates);
        convertSimpleResources(domainConfig, SERVER_GROUP_SCOPED_ROLE, baseAddress, updates);
        convertSimpleResources(domainConfig, HOST_SCOPED_ROLE, baseAddress, updates);
        if (domainConfig.hasDefined(CONSTRAINT)) {
            ModelNode constraints = domainConfig.get(CONSTRAINT);
            if (constraints.hasDefined(APPLICATION_CLASSIFICATION)) {
                convertApplicationClassificationConstraints(constraints.get(APPLICATION_CLASSIFICATION), baseAddress, updates);
            }
            if (constraints.hasDefined(SENSITIVITY_CLASSIFICATION)) {
                convertSensitivityClassificationConstraints(constraints.get(SENSITIVITY_CLASSIFICATION), baseAddress, updates);
            }
            if (constraints.hasDefined(VAULT_EXPRESSION)) {
                ModelNode address = baseAddress.clone().add(CONSTRAINT, VAULT_EXPRESSION);
                ModelNode ve = constraints.get(VAULT_EXPRESSION);
                // No add for this one; need to write attributes
                for (AttributeDefinition ad : SensitivityResourceDefinition.getWritableVaultAttributeDefinitions()) {
                    String attr = ad.getName();
                    if (ve.hasDefined(attr)) {
                        updates.add(Util.getWriteAttributeOperation(address, attr, ve.get(attr)));
                    }
                }
            }
        }
    }
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testProductInfo() throws Exception {
    final ModelNode setOrganizationOp = Util.getWriteAttributeOperation(PathAddress.EMPTY_ADDRESS, ORGANIZATION, "wildfly-core");
    executeOperation(setOrganizationOp, true);
    final ModelNode operation = new ModelNode();
    operation.get(OP_ADDR).set(PathAddress.EMPTY_ADDRESS.toModelNode());
    operation.get(OP).set(OPERATION_NAME);

    final List<Property> result = executeOperation(operation, true).asPropertyList();
    assertThat(result.size(), is(1));
    assertThat(result.get(0).getName(), is(SUMMARY));
    final ModelNode report = result.get(0).getValue();
    assertThat(report.isDefined(), is(true));
    assertThat(report.hasDefined(NODE_NAME), is(false));
    assertThat(report.hasDefined(HOSTNAME), is(true));
    assertThat(report.hasDefined(HOSTNAME), is(true));
    assertThat(report.hasDefined(ORGANIZATION), is(true));
    assertThat(report.get(ORGANIZATION).asString(), is("wildfly-core"));
    assertThat(report.hasDefined(PRODUCT_COMMUNITY_IDENTIFIER), is(true));
    assertThat(report.get(PRODUCT_COMMUNITY_IDENTIFIER).asString(), is(PROJECT_TYPE));
    assertThat(report.hasDefined(STANDALONE_DOMAIN_IDENTIFIER), is(true));
    assertThat(report.get(STANDALONE_DOMAIN_IDENTIFIER).asString(), is(ProcessType.STANDALONE_SERVER.name()));
    assertThat(report.hasDefined(OS), is(true));
    assertThat(report.hasDefined(CPU), is(true));
    assertThat(report.get(CPU).hasDefined(ARCH), is(true));
    assertThat(report.get(CPU).hasDefined(AVAILABLE_PROCESSORS), is(true));
    assertThat(report.hasDefined(JVM), is(true));
    assertThat(report.get(JVM).hasDefined(NAME), is(true));
    assertThat(report.get(JVM).hasDefined(JVM_VENDOR), is(true));
    assertThat(report.get(JVM).hasDefined(JVM_VERSION), is(true));
    assertThat(report.get(JVM).hasDefined(JVM_HOME), is(true));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private ModelNode createDcLockTakenCompositeWithRollback(ModelNode op) {
    ModelNode composite = createDcLockTakenComposite(op);

    ModelNode rollback = Util.getWriteAttributeOperation(SLAVE_ROOT_ADDRESS.clone().add(SYSTEM_PROPERTY, "rollback-does-not-exist" + String.valueOf(System.currentTimeMillis())), VALUE, "xxx");
    composite.get(STEPS).add(rollback);
    return composite;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testBadSocketBindingGroupIncludesWrite() throws Exception {
    KernelServices kernelServices = createKernelServices();

    PathAddress addr = PathAddress.pathAddress(SOCKET_BINDING_GROUP, "test-with-includes");
    ModelNode list = new ModelNode().add("test").add("standard-sockets").add("bad-SocketBindingGroup");
    ModelNode op = Util.getWriteAttributeOperation(addr, INCLUDES, list);

    ModelNode response = kernelServices.executeOperation(op);
    Assert.assertEquals(response.toString(), FAILED, response.get(OUTCOME).asString());
    Assert.assertTrue(response.toString(), response.get(FAILURE_DESCRIPTION).asString().contains("WFLYCTL0369"));
}
 

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

    KernelServices kernelServices = createKernelServices("host.xml");

    PathAddress pa = PathAddress.pathAddress(PathElement.pathElement(HOST, MASTER), PathElement.pathElement(SERVER_CONFIG, "server-one"));
    ModelNode op = Util.getWriteAttributeOperation(pa, GROUP, "does-not-exist");
    ModelNode response = kernelServices.executeOperation(op);
    Assert.assertEquals(response.toString(), FAILED, response.get(OUTCOME).asString());
    Assert.assertTrue(response.toString(), response.get(FAILURE_DESCRIPTION).asString().contains("WFLYCTL0369"));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testGoodSocketBindingGroupIncludesWrite() throws Exception {
    PathAddress addr = getSocketBindingGroupAddress("binding-one");
    ModelNode list = new ModelNode().add("binding-two");
    ModelNode op = Util.getWriteAttributeOperation(addr, INCLUDES, list);
    MockOperationContext operationContext = getOperationContext(addr);
    SocketBindingGroupResourceDefinition.createIncludesValidationHandler().execute(operationContext, op);
    operationContext.executeNextStep();
}