Java Util.getReadAttributeOperation方法代码示例

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testPost() throws Exception {
    ModelNode op = Util.getReadAttributeOperation(PathAddress.EMPTY_ADDRESS, "server-state");
    HttpPost post = new HttpPost(url.toURI());

    String cmdStr = op.toJSONString(true);
    StringEntity entity = new StringEntity(cmdStr);
    entity.setContentType(APPLICATION_JSON);
    post.setEntity(entity);

    assertNull(getCorrelationHeader(post));

    post.addHeader(HEADER, VALUE1);
    assertEquals(VALUE1, getCorrelationHeader(post));

    post.setHeader(HEADER, VALUE2);
    assertEquals(VALUE2, getCorrelationHeader(post));

    post.setHeader(HEADER, VALUE1);
    assertEquals(VALUE1, getCorrelationHeader(post));

    post.removeHeaders(HEADER);
    assertNull(getCorrelationHeader(post));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private static void validateTimeoutProperties(String host, String server, String baseTimeout, String domainAdder) throws IOException, MgmtOperationException {
    PathAddress pa = PathAddress.pathAddress(HOST, host);
    if (server != null) {
        pa = pa.append(RUNNING_SERVER, server);
    }
    ModelNode op = Util.getReadAttributeOperation(pa.append(RUNTIME_MXBEAN), "system-properties");
    ModelNode props = executeForResult(op, masterClient);
    if (baseTimeout == null) {
        assertFalse(props.toString(), props.hasDefined("jboss.as.management.blocking.timeout"));
    } else {
        assertEquals(props.toString(), baseTimeout, props.get("jboss.as.management.blocking.timeout").asString());
    }
    if (domainAdder == null) {
        assertFalse(props.toString(), props.hasDefined("org.wildfly.unsupported.test.domain-timeout-adder"));
    } else {
        assertEquals(props.toString(), domainAdder, props.get("org.wildfly.unsupported.test.domain-timeout-adder").asString());
    }
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private void attributeTest(String attribute, String accessType) throws IOException {
    ModelNode op = Util.getReadResourceDescriptionOperation(PROFILE.append(SUBSYSTEM));
    ModelNode resp = executeOp(op, SUCCESS);
    assertTrue(resp.toString(), resp.hasDefined(RESULT, ATTRIBUTES));
    // non storage=configuration attributes should not get registered even though the ResourceDefinition tries
    assertFalse(resp.toString(), resp.has(RESULT, ATTRIBUTES, attribute));

    op = Util.getReadAttributeOperation(PROFILE.append(SUBSYSTEM), attribute);
    executeOp(op, FAILED);

    op = Util.getReadResourceDescriptionOperation(SLAVE.append(MAIN_THREE).append(SUBSYSTEM));
    resp = executeOp(op, SUCCESS);
    assertEquals(resp.toString(), accessType, resp.get(RESULT, ATTRIBUTES, attribute, ACCESS_TYPE).asString());

    op = Util.getReadAttributeOperation(SLAVE.append(MAIN_THREE).append(SUBSYSTEM), attribute);
    resp = executeOp(op, SUCCESS);
    assertTrue(resp.toString(), resp.get(RESULT).asBoolean());
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private void addReadAttributeStep(OperationContext context, PathAddress address, boolean defaults, boolean resolve, FilteredData localFilteredData,
                                  ImmutableManagementResourceRegistration registry,
                                  AttributeDefinition.NameAndGroup attributeKey, Map<AttributeDefinition.NameAndGroup, GlobalOperationHandlers.AvailableResponse> responseMap) {
    // See if there was an override registered for the standard :read-attribute handling (unlikely!!!)
    OperationStepHandler overrideHandler = registry.getOperationHandler(PathAddress.EMPTY_ADDRESS, READ_ATTRIBUTE_OPERATION);
    if (overrideHandler != null &&
            (overrideHandler == ReadAttributeHandler.INSTANCE || overrideHandler == ReadAttributeHandler.RESOLVE_INSTANCE)) {
        // not an override
        overrideHandler = null;
    }

    OperationStepHandler readAttributeHandler = new ReadAttributeHandler(localFilteredData, overrideHandler, (resolve && resolvable));

    final ModelNode attributeOperation = Util.getReadAttributeOperation(address, attributeKey.getName());
    attributeOperation.get(ModelDescriptionConstants.INCLUDE_DEFAULTS).set(defaults);
    attributeOperation.get(ModelDescriptionConstants.RESOLVE_EXPRESSIONS).set(resolve);

    final ModelNode attrResponse = new ModelNode();
    GlobalOperationHandlers.AvailableResponse availableResponse = new GlobalOperationHandlers.AvailableResponse(attrResponse);
    responseMap.put(attributeKey, availableResponse);

    GlobalOperationHandlers.AvailableResponseWrapper wrapper = new GlobalOperationHandlers.AvailableResponseWrapper(readAttributeHandler, availableResponse);

    context.addStep(attrResponse, attributeOperation, wrapper, OperationContext.Stage.MODEL, true);
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private void addReadAttributeStep(OperationContext context, PathAddress address, boolean defaults, boolean resolve,
                                  FilteredData localFilteredData,
        ImmutableManagementResourceRegistration registry,
        AttributeDefinition.NameAndGroup attributeKey, Map<AttributeDefinition.NameAndGroup, GlobalOperationHandlers.AvailableResponse> responseMap) {
    // See if there was an override registered for the standard :read-attribute handling (unlikely!!!)
    OperationStepHandler overrideHandler = registry.getOperationHandler(PathAddress.EMPTY_ADDRESS, READ_ATTRIBUTE_OPERATION);
    if (overrideHandler != null
            && (overrideHandler == ReadAttributeHandler.INSTANCE || overrideHandler == ReadAttributeHandler.RESOLVE_INSTANCE)) {
        // not an override
        overrideHandler = null;
    }

    OperationStepHandler readAttributeHandler = new ReadAttributeHandler(localFilteredData, overrideHandler, (resolve && resolvable));

    final ModelNode attributeOperation = Util.getReadAttributeOperation(address, attributeKey.getName());
    attributeOperation.get(ModelDescriptionConstants.INCLUDE_DEFAULTS).set(defaults);
    attributeOperation.get(ModelDescriptionConstants.RESOLVE_EXPRESSIONS).set(resolve);

    final ModelNode attrResponse = new ModelNode();
    GlobalOperationHandlers.AvailableResponse availableResponse = new GlobalOperationHandlers.AvailableResponse(attrResponse);
    responseMap.put(attributeKey, availableResponse);

    GlobalOperationHandlers.AvailableResponseWrapper wrapper = new GlobalOperationHandlers.AvailableResponseWrapper(readAttributeHandler, availableResponse);

    context.addStep(attrResponse, attributeOperation, wrapper, OperationContext.Stage.MODEL, true);
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testNativeInterface() throws Exception {
    ModelNode opNode = Util.getReadAttributeOperation(PathAddress.pathAddress(SUBSYSTEM, LogStreamExtension.SUBSYSTEM_NAME), "log-file");
    readLogFile(opNode);

    opNode = Util.createEmptyOperation(LogStreamExtension.STREAM_LOG_FILE, PathAddress.pathAddress(SUBSYSTEM, LogStreamExtension.SUBSYSTEM_NAME));
    readLogFile(opNode);
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private ModelNode readSystemProperties(DomainClient client, PathAddress parent) throws IOException {
    PathAddress addr = parent.append("core-service", "platform-mbean").append("type", "runtime");
    ModelNode op = Util.getReadAttributeOperation(addr, "system-properties");
    ModelNode response = client.execute(op);
    ModelNode result = DomainTestSupport.validateResponse(response, true);
    Assert.assertNotNull(result);
    Assert.assertEquals(response.toString(), ModelType.OBJECT, result.getType());
    return result;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private String getServerProperty(DomainClient slaveClient, String propName) throws Exception {
    PathAddress addr = SLAVE_ADDR.append(SERVER, "server-affected")
            .append(CORE_SERVICE, PLATFORM_MBEAN).append(TYPE, "runtime");
    ModelNode op = Util.getReadAttributeOperation(addr, SYSTEM_PROPERTIES);
    ModelNode props = DomainTestUtils.executeForResult(op, slaveClient);
    for (ModelNode prop : props.asList()) {
        Property property = prop.asProperty();
        if (property.getName().equals(propName)) {
            return property.getValue().asString();
        }
    }
    return null;

}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private String getDeploymentProperty(DomainClient slaveClient, String qualifier) throws Exception {
    PathAddress addr = SLAVE_ADDR.append(SERVER, "server-affected")
            .append(CORE_SERVICE, PLATFORM_MBEAN).append(TYPE, "runtime");
    ModelNode op = Util.getReadAttributeOperation(addr, SYSTEM_PROPERTIES);
    ModelNode props = DomainTestUtils.executeForResult(op, slaveClient);
    String propName = "test.deployment.prop." + qualifier;
    for (ModelNode prop : props.asList()) {
        Property property = prop.asProperty();
        if (property.getName().equals(propName)) {
            return property.getValue().asString();
        }
    }
    return null;
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
protected void checkMaxHistorySize(DomainClient client,  int expectedSize, PathElement ... prefix) throws UnsuccessfulOperationException {
    PathAddress address = PathAddress.pathAddress().append(prefix).append(getAddress());
    ModelNode readMaxHistorySize = Util.getReadAttributeOperation(address, MAX_HISTORY);
    ModelNode result = executeForResult(client, readMaxHistorySize);
    assertThat(result.asInt(), is(expectedSize));
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private String getSlaveServerStatus(String serverName) throws Exception {
    ModelNode op = Util.getReadAttributeOperation(PathAddress.pathAddress(getSlaveRunningServerAddress(serverName)), "server-state");
    ModelNode result = slaveClient.execute(op);
    return validateResponse(result).asString();
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private String getSlaveHostStatus() throws Exception {
    ModelNode op = Util.getReadAttributeOperation(PathAddress.pathAddress(SLAVE_ROOT_ADDRESS), HOST_STATE);
    ModelNode result = slaveClient.execute(op);
    return validateResponse(result).asString();
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
private ModelNode createReadAttributeOp(PathAddress base) {
    PathAddress pa = base.append(SUBSYSTEM, LogStreamExtension.SUBSYSTEM_NAME);
    return Util.getReadAttributeOperation(pa, LogStreamExtension.LOG_FILE.getName());
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testDiscoveryOptionsOrdering() throws Exception {
    DomainClient slaveClient = domainSlaveLifecycleUtil.getDomainClient();
    ModelNode discoveryOptionsAddress = new ModelNode();
    discoveryOptionsAddress.add("host", "slave");
    discoveryOptionsAddress.add("core-service", "discovery-options");
    ModelNode readDiscoveryOptionsOrdering = Util.getReadAttributeOperation(PathAddress.pathAddress(discoveryOptionsAddress), DISCOVERY_OPTIONS);
    ModelNode expectedDiscoveryOptionsOrdering = new ModelNode();
    expectedDiscoveryOptionsOrdering.add("static-discovery", "start-option");
    ModelNode originalOptionsOrdering = new ModelNode();
    originalOptionsOrdering.add("static-discovery", "start-option");

    ModelNode discoveryOptionProperties = new ModelNode();
    discoveryOptionProperties.get(ACCESS_KEY).set("access_key");
    discoveryOptionProperties.get(SECRET_ACCESS_KEY).set("secret_access_key");
    discoveryOptionProperties.get(LOCATION).set("location");
    ModelNode addS3DiscoveryOption = getS3DiscoveryOptionAddOperation(discoveryOptionProperties);

    ModelNode addStaticDiscoveryOption = new ModelNode();
    addStaticDiscoveryOption.get(OP).set(ADD);
    addStaticDiscoveryOption.get(HOST).set("127.0.0.2");
    addStaticDiscoveryOption.get(PORT).set("9999");

    ModelNode result = slaveClient.execute(readDiscoveryOptionsOrdering);
    ModelNode returnVal = validateResponse(result);
    Assert.assertEquals(originalOptionsOrdering, returnVal);

    // (host=slave),(core-service=discovery-options),(discovery-option=option-one)
    ModelNode discoveryOptionAddressOne = discoveryOptionsAddress.clone().add("discovery-option", "option-one");
    addDiscoveryOptionTest(slaveClient, discoveryOptionAddressOne, addS3DiscoveryOption);
    expectedDiscoveryOptionsOrdering.add("discovery-option", "option-one");

    // (host=slave),(core-service=discovery-options),(static-discovery=option-two)
    ModelNode discoveryOptionAddressTwo = discoveryOptionsAddress.clone().add("static-discovery", "option-two");
    addDiscoveryOptionTest(slaveClient, discoveryOptionAddressTwo, addStaticDiscoveryOption);
    expectedDiscoveryOptionsOrdering.add("static-discovery", "option-two");

    // (host=slave),(core-service=discovery-options),(discovery-option=option-three)
    ModelNode discoveryOptionAddressThree = discoveryOptionsAddress.clone().add("discovery-option", "option-three");
    addDiscoveryOptionTest(slaveClient, discoveryOptionAddressThree, addS3DiscoveryOption);
    expectedDiscoveryOptionsOrdering.add("discovery-option", "option-three");

    result = slaveClient.execute(readDiscoveryOptionsOrdering);
    returnVal = validateResponse(result);
    Assert.assertEquals(expectedDiscoveryOptionsOrdering, returnVal);

    removeDiscoveryOptionTest(slaveClient, discoveryOptionAddressOne);
    removeDiscoveryOptionTest(slaveClient, discoveryOptionAddressTwo);
    removeDiscoveryOptionTest(slaveClient, discoveryOptionAddressThree);

    result = slaveClient.execute(readDiscoveryOptionsOrdering);
    returnVal = validateResponse(result);
    Assert.assertEquals(originalOptionsOrdering, returnVal);
}
 

import org.jboss.as.controller.operations.common.Util; //导入方法依赖的package包/类
@Test
public void testOptionsAttribute() throws Exception {
    DomainClient slaveClient = domainSlaveLifecycleUtil.getDomainClient();
    ModelNode discoveryOptionsAddress = new ModelNode();
    discoveryOptionsAddress.add("host", "slave");
    discoveryOptionsAddress.add("core-service", "discovery-options");
    ModelNode readOptionsAttr = Util.getReadAttributeOperation(PathAddress.pathAddress(discoveryOptionsAddress), ModelDescriptionConstants.OPTIONS);

    ModelNode item = new ModelNode();
    ModelNode value = item.get("static-discovery");
    value.get("name").set("start-option");
    value.get("protocol");
    value.get("host").set(new ValueExpression("${jboss.test.host.master.address}"));
    value.get("port").set(9999);

    ModelNode expectedOptions = new ModelNode();
    expectedOptions.add(item);
    ModelNode originalOptions = new ModelNode();
    originalOptions.add(item);

    ModelNode discoveryOptionProperties = new ModelNode();
    discoveryOptionProperties.get(ACCESS_KEY).set("access_key");
    discoveryOptionProperties.get(SECRET_ACCESS_KEY).set("secret_access_key");
    discoveryOptionProperties.get(LOCATION).set("location");
    ModelNode addS3DiscoveryOption = getS3DiscoveryOptionAddOperation(discoveryOptionProperties);

    ModelNode addStaticDiscoveryOption = new ModelNode();
    addStaticDiscoveryOption.get(OP).set(ADD);
    addStaticDiscoveryOption.get(HOST).set("127.0.0.2");
    addStaticDiscoveryOption.get(PORT).set("9999");

    ModelNode result = slaveClient.execute(readOptionsAttr);
    ModelNode returnVal = validateResponse(result);
    Assert.assertEquals(originalOptions, returnVal);

    // (host=slave),(core-service=discovery-options),(discovery-option=option-one)
    ModelNode discoveryOptionAddressOne = discoveryOptionsAddress.clone().add("discovery-option", "option-one");
    addDiscoveryOptionTest(slaveClient, discoveryOptionAddressOne, addS3DiscoveryOption);

    item = new ModelNode();
    value = item.get("custom-discovery");
    value.get("name").set("option-one");
    value.get("code").set("org.jboss.as.host.controller.discovery.S3Discovery");
    value.get("module").set("org.jboss.as.host.controller.discovery");
    value.get("properties").set(discoveryOptionProperties);
    expectedOptions.add(item);

    // (host=slave),(core-service=discovery-options),(static-discovery=option-two)
    ModelNode discoveryOptionAddressTwo = discoveryOptionsAddress.clone().add("static-discovery", "option-two");
    addDiscoveryOptionTest(slaveClient, discoveryOptionAddressTwo, addStaticDiscoveryOption);
    item = new ModelNode();
    value = item.get("static-discovery");
    value.get("name").set("option-two");
    value.get("protocol");
    value.get("host").set("127.0.0.2");
    value.get("port").set(9999);
    expectedOptions.add(item);

    // (host=slave),(core-service=discovery-options),(discovery-option=option-three)
    ModelNode discoveryOptionAddressThree = discoveryOptionsAddress.clone().add("discovery-option", "option-three");
    addDiscoveryOptionTest(slaveClient, discoveryOptionAddressThree, addS3DiscoveryOption);
    item = new ModelNode();
    value = item.get("custom-discovery");
    value.get("name").set("option-three");
    value.get("code").set("org.jboss.as.host.controller.discovery.S3Discovery");
    value.get("module").set("org.jboss.as.host.controller.discovery");
    value.get("properties").set(discoveryOptionProperties);
    expectedOptions.add(item);

    result = slaveClient.execute(readOptionsAttr);
    returnVal = validateResponse(result);
    Assert.assertEquals(expectedOptions, returnVal);

    removeDiscoveryOptionTest(slaveClient, discoveryOptionAddressOne);
    removeDiscoveryOptionTest(slaveClient, discoveryOptionAddressTwo);
    removeDiscoveryOptionTest(slaveClient, discoveryOptionAddressThree);

    result = slaveClient.execute(readOptionsAttr);
    returnVal = validateResponse(result);
    Assert.assertEquals(originalOptions, returnVal);
}