Java Util.createAddOperation方法代码示例

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Override
    protected void addConfiguration(ManageableResourceBuildParameters<S, SubsystemResource.Parent> params, TaskContext taskContext) {
        super.addConfiguration(params, taskContext);
        // add jmx subsystem default config
        /*
        <profile>
    <subsystem xmlns="urn:jboss:domain:jmx:1.3">
        <expose-resolved-model/>
        <expose-expression-model/>
        <remoting-connector/>
    </subsystem>
</profile>
         */
        final ManageableServerConfiguration serverConfiguration = params.getServerConfiguration();
        final PathAddress subsystemPathAddress = params.getResource().getSubsystemResourcePathAddress(getSubsystem());
        final ModelNode exposeResolvedModelAddOperation = Util.createAddOperation(subsystemPathAddress.append(PathElement.pathElement(EXPOSE_MODEL, RESOLVED)));
        serverConfiguration.executeManagementOperation(exposeResolvedModelAddOperation);
        final ModelNode exposeExpressionModelAddOperation = Util.createAddOperation(subsystemPathAddress.append(PathElement.pathElement(EXPOSE_MODEL, EXPRESSION)));
        serverConfiguration.executeManagementOperation(exposeExpressionModelAddOperation);
        final ModelNode remotingConnectorAddOperation = Util.createAddOperation(subsystemPathAddress.append(PathElement.pathElement(REMOTING_CONNECTOR, JMX)));
        serverConfiguration.executeManagementOperation(remotingConnectorAddOperation);
    }
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
public ModelNode toModelNode() {
    /*
        "path" => "audit.log",
        "relative-to" => "jboss.server.log.dir",
        "format" => "JSON",
        "operation" => "add",
        "address" => [
            ("subsystem" => "elytron"),
            ("file-audit-log" => "local-audit")
        ]
         */
    final PathAddress pathAddress = subsystemPathAddress.append("file-audit-log", fileAuditLog);
    final ModelNode operation = Util.createAddOperation(pathAddress);
    if (path != null) {
        operation.get("path").set(path);
    }
    if (relativeTo != null) {
        operation.get("relative-to").set(relativeTo);
    }
    if (format != null) {
        operation.get("format").set(format);
    }
    return operation;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Override
protected void addConfiguration(ManageableResourceBuildParameters<S, SubsystemResource.Parent> params, TaskContext taskContext) {
    // reuse default empty config add from super
    super.addConfiguration(params, taskContext);
    // and add default permissions
        /*
        <subsystem xmlns="urn:jboss:domain:security-manager:1.0">
            <deployment-permissions>
                <maximum-set>
                    <permission class="java.security.AllPermission"/>
                </maximum-set>
            </deployment-permissions>
        </subsystem>
         */

    final SubsystemResource.Parent parentResource = params.getResource();
    final PathAddress subsystemPathAddress = parentResource.getSubsystemResourcePathAddress(getSubsystem());
    final PathAddress deploymentPermissionsPathAddress = subsystemPathAddress.append(DEPLOYMENT_PERMISSIONS, DEPLOYMENT_PERMISSIONS_NAME);
    final ModelNode deploymentPermissionsAddOperation = Util.createAddOperation(deploymentPermissionsPathAddress);
    final ModelNode maximumPermissions = new ModelNode();
    maximumPermissions.get(CLASS_ATTR_NAME).set(CLASS_ATTR_VALUE);
    deploymentPermissionsAddOperation.get(MAXIMUM_PERMISSIONS).add(maximumPermissions);
    parentResource.getServerConfiguration().executeManagementOperation(deploymentPermissionsAddOperation);
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
public ModelNode toModelNode() {
        /*
           "sasl-server-factory" => "global",
        "filters" => [{"provider-name" => "WildFlyElytron"}],
        "operation" => "add",
        "address" => [
            ("subsystem" => "elytron"),
            ("mechanism-provider-filtering-sasl-server-factory" => "elytron")
        ]
         */
    final PathAddress pathAddress = subsystemPathAddress.append("mechanism-provider-filtering-sasl-server-factory", mechanismProviderFilteringSaslServerFactory);
    final ModelNode operation = Util.createAddOperation(pathAddress);
    if (saslServerFactory != null) {
        operation.get("sasl-server-factory").set(saslServerFactory);
    }
    if (filters != null && !filters.isEmpty()) {
        final ModelNode filtersNode = operation.get("filters").setEmptyList();
        for (String filter : filters) {
            filtersNode.add("provider-name",filter);
        }
    }
    return operation;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
public ModelNode toModelNode() {
     /*
          "attribute" => "groups",
        "operation" => "add",
        "address" => [
            ("subsystem" => "elytron"),
            ("simple-role-decoder" => "groups-to-roles")
        ]
         */
    final PathAddress pathAddress = subsystemPathAddress.append("simple-role-decoder", simpleRoleDecoder);
    final ModelNode operation = Util.createAddOperation(pathAddress);
    if (attribute != null) {
        operation.get("attribute").set(attribute);
    }
    return operation;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
public ModelNode toModelNode() {
    final PathAddress pathAddress = subsystemPathAddress.append("security-domain", securityDomain);
    final ModelNode operation = Util.createAddOperation(pathAddress);
    if (permissionMapper != null) {
        operation.get("permission-mapper").set(permissionMapper);
    }
    if (defaultRealm != null) {
        operation.get("default-realm").set(defaultRealm);
    }
    if (securityEventListener != null) {
        operation.get("security-event-listener").set(securityEventListener);
    }
    if (realms != null && !realms.isEmpty()) {
        final ModelNode operationRealms = operation.get("realms").setEmptyList();
        for (Realm realm : realms) {
            operationRealms.add(realm.toModelNode());
        }
    }
    return operation;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
public ModelNode toModelNode() {
        /*
           "sasl-server-factory" => "elytron",
        "properties" => {"wildfly.sasl.local-user.default-user" => "$local"},
        "operation" => "add",
        "address" => [
            ("subsystem" => "elytron"),
            ("configurable-sasl-server-factory" => "configured")
        ]
         */
    final PathAddress pathAddress = subsystemPathAddress.append("configurable-sasl-server-factory", configurableSaslServerFactory);
    final ModelNode operation = Util.createAddOperation(pathAddress);
    if (saslServerFactory != null) {
        operation.get("sasl-server-factory").set(saslServerFactory);
    }
    if (properties != null && !properties.isEmpty()) {
        final ModelNode propertiesNode = operation.get("properties");
        for (String propertyName : properties.stringPropertyNames()) {
            propertiesNode.get(propertyName).set(properties.getProperty(propertyName));
        }
    }
    return operation;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
public ModelNode toModelNode() {
        /*
          "roles" => ["SuperUser"],
        "operation" => "add",
        "address" => [
            ("subsystem" => "elytron"),
            ("constant-role-mapper" => "super-user-mapper")
        ]
         */
    final PathAddress pathAddress = subsystemPathAddress.append("constant-role-mapper", constantRoleMapper);
    final ModelNode operation = Util.createAddOperation(pathAddress);
    if (roles != null && !roles.isEmpty()) {
        final ModelNode rolesNode = operation.get("roles").setEmptyList();
        for (String role : roles) {
            rolesNode.add(role);
        }
    }
    return operation;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private void addDeploymentScanner() throws Exception {
    ModelNode addOp = Util.createAddOperation(PathAddress.pathAddress(PathElement.pathElement(EXTENSION,
            "org.jboss.as.deployment-scanner")));
    ModelNode result = executeOperation(addOp);
    assertEquals("Unexpected outcome of adding the test deployment scanner extension: " + addOp,
            ModelDescriptionConstants.SUCCESS, result.get("outcome").asString());
    addOp = Util.createAddOperation(PathAddress.pathAddress(PathElement.pathElement(SUBSYSTEM, "deployment-scanner")));
    result = executeOperation(addOp);
    assertEquals("Unexpected outcome of adding the test deployment scanner subsystem: " + addOp,
            ModelDescriptionConstants.SUCCESS, result.get("outcome").asString());
    // add deployment scanner
    final ModelNode op = getAddDeploymentScannerOp();
    result = executeOperation(op);
    assertEquals("Unexpected outcome of adding the test deployment scanner: " + op, ModelDescriptionConstants.SUCCESS,
            result.get("outcome").asString());
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private ModelNode parseChild(XMLExtendedStreamReader reader) throws XMLStreamException {
    ModelNode add = null;
    int count = reader.getAttributeCount();
    for (int i = 0; i < count; i++) {
        final String value = reader.getAttributeValue(i);
        final String attribute = reader.getAttributeLocalName(i);
        switch (attribute) {
            case "name": {
                add = Util.createAddOperation(PathAddress.pathAddress(
                        PathElement.pathElement(ModelDescriptionConstants.SUBSYSTEM, SUBSYSTEM_NAME),
                        PathElement.pathElement("child", value)));
                break;
            }
            default: {
                throw ParseUtils.unexpectedAttribute(reader, i);
            }
        }
    }
    if (add == null) {
        throw ParseUtils.missingRequired(reader, Collections.singleton("child"));
    }
    // Require no content
    ParseUtils.requireNoContent(reader);
    return add;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testCannotAccessAttributeWhenResourceDoesNotExist() throws Exception {
    //Just make sure it works as expected for an existent resource
    ModelNode op = Util.createAddOperation(PathAddress.pathAddress(new ModelNode().add("test", "exists")));
    executeForResult(op);

    op = createOperation(ModelDescriptionConstants.READ_ATTRIBUTE_OPERATION, "test", "exists");
    op.get(ModelDescriptionConstants.NAME).set("attr");
    ModelNode result = executeForResult(op);
    Assert.assertEquals("default", result.asString());

    //This should fail
    op = createOperation(ModelDescriptionConstants.READ_ATTRIBUTE_OPERATION, "test", "notthere");
    op.get(ModelDescriptionConstants.NAME).set("attr");
    executeForFailure(op);
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Override
protected void addConfiguration(ManageableResourceBuildParameters<S, SubsystemResource.Parent> params, TaskContext taskContext) {
    /*
        <subsystem xmlns="urn:jboss:domain:batch-jberet:1.0">
            <default-job-repository name="in-memory"/>
            <default-thread-pool name="batch"/>
            <job-repository name="in-memory">
                <in-memory/>
            </job-repository>
            <thread-pool name="batch">
                <max-threads count="10"/>
                <keepalive-time time="30" unit="seconds"/>
            </thread-pool>
        </subsystem>
         */
    final SubsystemResource.Parent parentResource = params.getResource();
    final Operations.CompositeOperationBuilder compositeOperationBuilder = Operations.CompositeOperationBuilder.create();
    final PathAddress subsystemPathAddress = parentResource.getSubsystemResourcePathAddress(getSubsystem());
    final ModelNode subsystemAddOperation = Util.createAddOperation(subsystemPathAddress);
    subsystemAddOperation.get(DEFAULT_JOB_REPOSITORY_ATTR_NAME).set(DEFAULT_JOB_REPOSITORY_ATTR_VALUE);
    subsystemAddOperation.get(DEFAULT_THREAD_POOL_ATTR_NAME).set(DEFAULT_THREAD_POOL_ATTR_VALUE);
    compositeOperationBuilder.addStep(subsystemAddOperation);
    // add default job repository
    final PathAddress jobReporsitoryPathAddress = subsystemPathAddress.append(IN_MEMORY_JOB_REPOSITORY, DEFAULT_JOB_REPOSITORY_ATTR_VALUE);
    final ModelNode jobReporsitoryAddOperation = Util.createAddOperation(jobReporsitoryPathAddress);
    compositeOperationBuilder.addStep(jobReporsitoryAddOperation);
    // add default thread pool
    final PathAddress threadPoolPathAddress = subsystemPathAddress.append(THREAD_POOL, DEFAULT_THREAD_POOL_ATTR_VALUE);
    final ModelNode threadPoolAddOperation = Util.createAddOperation(threadPoolPathAddress);
    threadPoolAddOperation.get(MAX_THREADS).set(MAX_THREADS_VALUE);
    final ModelNode keepAliveTime = new ModelNode();
    keepAliveTime.get(KEEPALIVE_TIME_TIME_ATTR_NAME).set(KEEPALIVE_TIME_TIME_ATTR_VALUE);
    keepAliveTime.get(KEEPALIVE_TIME_UNIT_ATTR_NAME).set(KEEPALIVE_TIME_UNIT_ATTR_VALUE);
    threadPoolAddOperation.get(KEEPALIVE_TIME).set(keepAliveTime);
    compositeOperationBuilder.addStep(threadPoolAddOperation);
    parentResource.getServerConfiguration().executeManagementOperation(compositeOperationBuilder.build().getOperation());
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
public ModelNode toModelNode() {
    final PathAddress pathAddress = subsystemPathAddress.append("identity-realm", identityRealm);
    final ModelNode operation = Util.createAddOperation(pathAddress);
    if (identity != null) {
        operation.get("identity").set(identity);
    }
    return operation;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private static void setLocalCacheFileStore(Operations.CompositeOperationBuilder compositeOperationBuilder, PathAddress localCachePathAddress, boolean passivation, boolean purge) {
    final PathAddress localCacheFileStorePathAddress = localCachePathAddress.append(STORE, STORE_NAME_FILE);
    final ModelNode localCacheFileStoreAddOperation = Util.createAddOperation(localCacheFileStorePathAddress);
    localCacheFileStoreAddOperation.get(PASSIVATION_ATTR_NAME).set(passivation);
    localCacheFileStoreAddOperation.get(PURGE_ATTR_NAME).set(purge);
    compositeOperationBuilder.addStep(localCacheFileStoreAddOperation);
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Override
protected void addConfiguration(ManageableResourceBuildParameters<S, SubsystemResource.Parent> params, TaskContext taskContext) {
    final SubsystemResource.Parent parentResource = params.getResource();
    // add subsystem with default config
            /*
        <subsystem xmlns="urn:jboss:domain:singleton:1.0">
        <singleton-policies default="default">
            <singleton-policy name="default" cache-container="server">
                <simple-election-policy/>
            </singleton-policy>
        </singleton-policies>
        </subsystem>
        */
    final ManageableServerConfiguration serverConfiguration = parentResource.getServerConfiguration();
    final Operations.CompositeOperationBuilder compositeOperationBuilder = Operations.CompositeOperationBuilder.create();
    final PathAddress subsystemPathAddress = parentResource.getSubsystemResourcePathAddress(getSubsystem());
    final ModelNode subsystemAddOperation = Util.createAddOperation(subsystemPathAddress);
    subsystemAddOperation.get(DEFAULT_ATTR_NAME).set(DEFAULT_ATTR_VALUE);
    compositeOperationBuilder.addStep(subsystemAddOperation);
    // add default policy
    final PathAddress singletonPolicyPathAddress = subsystemPathAddress.append(SINGLETON_POLICY, DEFAULT_ATTR_VALUE);
    final ModelNode singletonPolicyAddOperation = Util.createAddOperation(singletonPolicyPathAddress);
    singletonPolicyAddOperation.get(CACHE_CONTAINER_ATTR_NAME).set(CACHE_CONTAINER_ATTR_VALUE);
    compositeOperationBuilder.addStep(singletonPolicyAddOperation);
    // add election policy
    final PathAddress electionPolicyPathAddress = singletonPolicyPathAddress.append(ELECTION_POLICY, ELECTION_POLICY_NAME);
    final ModelNode electionPolicyAddOperation = Util.createAddOperation(electionPolicyPathAddress);
    compositeOperationBuilder.addStep(electionPolicyAddOperation);
    serverConfiguration.executeManagementOperation(compositeOperationBuilder.build().getOperation());
}