import org.jboss.as.controller.PathElement; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void readElement(XMLExtendedStreamReader reader, List<ModelNode> list) throws XMLStreamException {
    PathAddress address = PathAddress.pathAddress(PathElement.pathElement(SUBSYSTEM, SmppExtension.SUBSYSTEM_NAME));

    final ModelNode subsystem = new ModelNode();
    subsystem.get(OP).set(ADD);
    subsystem.get(OP_ADDR).set(address.toModelNode());
    list.add(subsystem);

    // mbean elements
    while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
        switch (Namespace.forUri(reader.getNamespaceURI())) {
            case SMPPEXT_1_0: {
                final String tagName = reader.getLocalName();
                if (tagName.equals(SmppMbeanDefinition.MBEAN)) {
                    parseMbean(reader, address, list);
                }
                break;
            }
            default: {
                throw unexpectedElement(reader);
            }
        }
    }
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
/**
 * Tests that the xml is parsed into the correct operations
 */
@Test
public void testParseSubsystem() throws Exception {
    // Parse the subsystem xml into operations
    String subsystemXml = getSubsystemXml();
    List<ModelNode> operations = super.parse(subsystemXml);

    // /Check that we have the expected number of operations
    Assert.assertEquals(1, operations.size());

    // Check that each operation has the correct content
    // The add subsystem operation will happen first
    ModelNode addSubsystem = operations.get(0);
    Assert.assertEquals(ADD, addSubsystem.get(OP).asString());
    PathAddress addr = PathAddress.pathAddress(addSubsystem.get(OP_ADDR));
    Assert.assertEquals(1, addr.size());
    PathElement element = addr.getElement(0);
    Assert.assertEquals(SUBSYSTEM, element.getKey());
    Assert.assertEquals(NestSubsystemExtension.SUBSYSTEM_NAME, element.getValue());
    Assert.assertEquals(true, addSubsystem.get(NestSubsystemExtension.NEST_ENABLED_ATTR).resolve().asBoolean());
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
/**
 * Starts a controller with the given subsystem xml and then checks that a second controller started with the
 * operations from its describe action results in the same model
 */
@Test
public void testDescribeHandler() throws Exception {
    String subsystemXml = getSubsystemXml();
    KernelServices servicesA = createKernelServicesBuilder(null).setSubsystemXml(subsystemXml).build();

    // Get the model and the describe operations from the first controller
    ModelNode modelA = servicesA.readWholeModel();
    ModelNode describeOp = new ModelNode();
    describeOp.get(OP).set(DESCRIBE);
    describeOp.get(OP_ADDR).set(
            PathAddress.pathAddress(PathElement.pathElement(SUBSYSTEM, NestSubsystemExtension.SUBSYSTEM_NAME))
                    .toModelNode());
    ModelNode executeOperation = servicesA.executeOperation(describeOp);
    List<ModelNode> operations = super.checkResultAndGetContents(executeOperation).asList();

    // Install the describe options from the first controller into a second controller
    KernelServices servicesB = createKernelServicesBuilder(null).setBootOperations(operations).build();
    ModelNode modelB = servicesB.readWholeModel();

    // Make sure the models from the two controllers are identical
    super.compare(modelA, modelB);
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
protected void getNestList(HawkularServerFraction fraction, List<ModelNode> list) {
    ModelNode node = new ModelNode();
    node.get(OP_ADDR).set(EXTENSION, "org.hawkular.nest");
    node.get(OP).set(ADD);
    list.add(node);

    PathAddress address = PathAddress.pathAddress(PathElement.pathElement(SUBSYSTEM, "hawkular-nest"));

    node = new ModelNode();
    node.get(OP_ADDR).set(address.toModelNode());
    node.get(OP).set(ADD);
    node.get("nest-name").set("autogenerate");
    node.get("enabled").set(true);
    list.add(node);

    list.add(property("hawkular.metrics.waitForService",
            SwarmProperties.propertyVar("hawkular.metrics.waitForService", "True")));

    list.add(property("hawkular.backend",
            SwarmProperties.propertyVar("hawkular.backend", "embedded_cassandra")));

    list.add(property("keycloak.server.url",
            SwarmProperties.propertyVar("keycloak.server.url", "http://localhost:8080/auth")));
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
@Override
public List<ModelNode> getList(KeycloakServerFraction fraction) {
    List<ModelNode> list = new ArrayList<>();

    PathAddress address = PathAddress.pathAddress(PathElement.pathElement(SUBSYSTEM, "keycloak-server"));

    ModelNode node = new ModelNode();
    node.get(OP_ADDR).set(EXTENSION, "org.keycloak.keycloak-wildfly-server-subsystem");
    node.get(OP).set(ADD);
    list.add(node);

    node = new ModelNode();
    node.get(OP_ADDR).set(address.toModelNode());
    node.get(OP).set(ADD);
    list.add(node);

    return list;
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
@Override
public List<ModelNode> getList(KeycloakFraction fraction) {
    List<ModelNode> list = new ArrayList<>();

    PathAddress address = PathAddress.pathAddress(PathElement.pathElement(SUBSYSTEM, "keycloak"));

    ModelNode node = new ModelNode();
    node.get(OP_ADDR).set(EXTENSION, "org.keycloak.keycloak-adapter-subsystem");
    node.get(OP).set(ADD);
    list.add(node);

    node = new ModelNode();
    node.get(OP_ADDR).set(address.toModelNode());
    node.get(OP).set(ADD);
    list.add(node);

    return list;

}
 

import org.jboss.as.controller.PathElement; //导入依赖的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.PathElement; //导入依赖的package包/类
@Override
protected ServerMigrationTaskResult updateConfiguration(ModelNode config, S source, SubsystemResource subsystemResource, TaskContext taskContext, TaskEnvironment taskEnvironment) {
    final PathAddress subsystemPathAddress = subsystemResource.getResourcePathAddress();
    final ManageableServerConfiguration serverConfiguration = subsystemResource.getServerConfiguration();
    // read env properties
    final String httpConnectorName = taskEnvironment.getPropertyAsString(EnvironmentProperties.HTTP_CONNECTOR_NAME, DEFAULT_HTTP_CONNECTOR_NAME);
    final String connectorRefName = taskEnvironment.getPropertyAsString(EnvironmentProperties.CONNECTOR_REF_NAME, DEFAULT_CONNECTOR_REF_NAME);
    final String securityRealmName = taskEnvironment.getPropertyAsString(EnvironmentProperties.SECURITY_REALM_NAME, DEFAULT_SECURITY_REALM_NAME);
    // if not defined add http connector
    if (!config.hasDefined(HTTP_CONNECTOR, httpConnectorName)) {
        final PathAddress httpRemotingConnectorPathAddress = subsystemPathAddress.append(PathElement.pathElement(HTTP_CONNECTOR, httpConnectorName));
        final ModelNode httpRemotingConnectorAddOp = Util.createEmptyOperation(ADD, httpRemotingConnectorPathAddress);
        httpRemotingConnectorAddOp.get(CONNECTOR_REF).set(connectorRefName);
        httpRemotingConnectorAddOp.get(SECURITY_REALM).set(securityRealmName);
        serverConfiguration.executeManagementOperation(httpRemotingConnectorAddOp);
        taskContext.getLogger().debugf("Http connector %s added to Remoting subsystem configuration.", httpConnectorName);
        return ServerMigrationTaskResult.SUCCESS;
    } else {
        return ServerMigrationTaskResult.SKIPPED;
    }
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
@Test
public void testParseSubsystem() throws Exception {
    //Parse the subsystem xml into operations
	String subsystemXml = ObjectConverterUtil.convertToString(new FileReader("src/test/resources/teiid-sample-config.xml"));
    List<ModelNode> operations = super.parse(subsystemXml);

    ///Check that we have the expected number of operations
    Assert.assertEquals(5, operations.size());

    //Check that each operation has the correct content
    ModelNode addSubsystem = operations.get(0);
    Assert.assertEquals(ADD, addSubsystem.get(OP).asString());
    PathAddress addr = PathAddress.pathAddress(addSubsystem.get(OP_ADDR));
    Assert.assertEquals(1, addr.size());
    PathElement element = addr.getElement(0);
    Assert.assertEquals(SUBSYSTEM, element.getKey());
    Assert.assertEquals(TeiidExtension.TEIID_SUBSYSTEM, element.getValue());
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
private void registerManagementNodes() {
    QName applicationName = _deployment.getName();
    if (applicationName == null) {
        return;
    }

    ServiceController<?> adminService = _deployUnit.getServiceRegistry().getService(
            SwitchYardAdminService.SERVICE_NAME);
    if (adminService == null) {
        return;
    }

    BaseSwitchYard switchYard = BaseSwitchYard.class.cast(adminService.getValue());
    if (switchYard == null) {
        return;
    }

    ModelNode deployNode = _deployUnit.createDeploymentSubModel(SwitchYardExtension.SUBSYSTEM_NAME,
            PathElement.pathElement(SwitchYardModelConstants.APPLICATION, applicationName.toString()));

    Application application = switchYard.getApplication(applicationName);
    if (application == null) {
        return;
    }
    deployNode.set(ModelNodeCreationUtil.createApplicationNode(application));
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
private void cancel(DomainClient client, String host, String server, String opName,
                       OperationContext.ExecutionStatus targetStatus, long executionStart, boolean serverOpOnly) throws Exception {
    PathAddress address = PathAddress.pathAddress(PathElement.pathElement(HOST, host));
    if (server != null) {
        address = address.append(PathElement.pathElement(SERVER, server));
    }
    address = address.append(MGMT_CONTROLLER);

    final String opToCancel = findActiveOperation(client, address, opName, targetStatus, executionStart, serverOpOnly);
    address = address.append(PathElement.pathElement(ACTIVE_OPERATION, opToCancel));

    ModelNode result = executeForResult(Util.createEmptyOperation("cancel", address), client);

    boolean retVal = result.asBoolean();
    assertTrue(result.asString(), retVal);
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
@Override
public void unregisterRemoteHost(String id, Long remoteConnectionId, boolean cleanShutdown) {
    DomainSlaveHostRegistrations.DomainHostConnection hostRegistration = slaveHostRegistrations.getRegistration(id);
    if (hostRegistration != null) {
        if ((remoteConnectionId == null || remoteConnectionId.equals(hostRegistration.getRemoteConnectionId()))) {
            final SlaveHostPinger pinger = hostRegistration.getPinger();
            if (pinger != null) {
                pinger.cancel();
            }
            boolean registered = hostProxies.remove(id) != null;
            modelNodeRegistration.unregisterProxyController(PathElement.pathElement(HOST, id));

            if (registered) {
                final String address = hostRegistration.getAddress();
                final Event event = cleanShutdown ? create(HostConnectionInfo.EventType.UNREGISTERED, address) : create(HostConnectionInfo.EventType.UNCLEAN_UNREGISTRATION, address);
                slaveHostRegistrations.unregisterHost(id, event);
                if (!cleanShutdown) {
                    DOMAIN_LOGGER.lostConnectionToRemoteHost(id);
                } else {
                    DOMAIN_LOGGER.unregisteredRemoteSlaveHost(id);
                }
            }
        }
    }

}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
@Override
protected void initModel(ManagementModel managementModel) {
    ManagementResourceRegistration registration = managementModel.getRootResourceRegistration();
    GlobalOperationHandlers.registerGlobalOperations(registration, processType);
    registration.registerOperationHandler(new SimpleOperationDefinitionBuilder("setup", new NonResolvingResourceDescriptionResolver())
            .setPrivateEntry()
            .build()
            , new OperationStepHandler() {
        @Override
        public void execute(OperationContext context, ModelNode operation) throws OperationFailedException {
            createModel(context, model);
        }
    });

    GlobalNotifications.registerGlobalNotifications(registration, processType);

    ManagementResourceRegistration child = registration.registerSubModel(new SimpleResourceDefinition(PathElement.pathElement("test"), new NonResolvingResourceDescriptionResolver()));
    child.registerReadOnlyAttribute(TestUtils.createNillableAttribute("prop", ModelType.STRING), null);

    managementModel.getRootResource().getModel().set(model);
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
/**
 * @see #getDeploymentSubModel(String, org.jboss.as.controller.PathAddress)
 */
static ModelNode getDeploymentSubModel(final String subsystemName, final PathAddress address, final Resource resource, final DeploymentUnit unit) {
    final Resource root = unit.getAttachment(DEPLOYMENT_RESOURCE);
    synchronized (root) {
        final ImmutableManagementResourceRegistration registration = unit.getAttachment(REGISTRATION_ATTACHMENT);
        final PathElement subsystemPath = PathElement.pathElement(SUBSYSTEM, subsystemName);
        if (address == PathAddress.EMPTY_ADDRESS) {
            return getOrCreate(root, subsystemPath, resource).getModel();
        }
        Resource parent = getOrCreate(root, subsystemPath);
        int count = address.size() - 1;
        for (int index = 0; index < count; index++) {
            parent = getOrCreate(parent, address.getElement(index));
        }
        final ImmutableManagementResourceRegistration subModel = registration.getSubModel(getSubsystemAddress(subsystemName, address));
        if (subModel == null) {
            throw new IllegalStateException(address.toString());
        }
        return getOrCreate(parent, address.getLastElement(), resource).getModel();
    }
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
private TrivialResourceDefinition(String pathKey, ResourceDescriptionResolver resourceDescriptionResolver, AbstractAddStepHandler add, AttributeDefinition[] attributes,
        Map<AttributeDefinition, OperationStepHandler> readOnlyAttributes, Map<OperationDefinition, OperationStepHandler> operations, List<ResourceDefinition> children,
        RuntimeCapability<?>[] runtimeCapabilities) {
    super(new Parameters(PathElement.pathElement(pathKey),
            resourceDescriptionResolver)
        .setAddHandler(add)
        .setRemoveHandler(new TrivialCapabilityServiceRemoveHandler(add, runtimeCapabilities))
        .setAddRestartLevel(OperationEntry.Flag.RESTART_RESOURCE_SERVICES)
        .setRemoveRestartLevel(OperationEntry.Flag.RESTART_RESOURCE_SERVICES)
        .setCapabilities(runtimeCapabilities));

    this.pathKey = pathKey;
    this.firstCapability = runtimeCapabilities[0];
    this.attributes = attributes;
    this.readOnlyAttributes = readOnlyAttributes;
    this.operations = operations;
    this.children = children;
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
private void executeReloadOperation(Boolean restartServers, Boolean adminOnly) throws Exception {
    ModelNode operation = new ModelNode();
    operation.get(OP).set("reload");
    operation.get(OP_ADDR).set(PathAddress.pathAddress(PathElement.pathElement(HOST, "master")).toModelNode());
    if (restartServers != null) {
        operation.get(ModelDescriptionConstants.RESTART_SERVERS).set(restartServers);
    }
    if (adminOnly != null) {
        operation.get(ModelDescriptionConstants.ADMIN_ONLY).set(adminOnly);
    }
    final TestControllerClient client = getControllerClient();
    try {
        Assert.assertEquals(SUCCESS, client.executeAwaitClosed(operation).get(OUTCOME).asString());
    } catch (IOException canHappenWhenShuttingDownController) {
    }
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
private void testTransformers(ModelTestControllerVersion controllerVersion) throws Exception {

        KernelServicesBuilder builder = createKernelServicesBuilder(AdditionalInitialization.MANAGEMENT);
        ModelVersion version = ModelVersion.create(2, 0, 0);
        builder.createLegacyKernelServicesBuilder(AdditionalInitialization.MANAGEMENT, controllerVersion, version)
                .addMavenResourceURL("org.jboss.eap:wildfly-security-manager:" + controllerVersion.getMavenGavVersion());

        KernelServices mainServices = builder.build();
        assertTrue(mainServices.isSuccessfulBoot());
        KernelServices legacyServices = mainServices.getLegacyServices(version);
        assertNotNull(legacyServices);
        assertTrue(legacyServices.isSuccessfulBoot());

        PathAddress subsystemAddress = PathAddress.pathAddress(PathElement.pathElement(SUBSYSTEM, getMainSubsystemName()));
        ModelTestUtils.checkFailedTransformedBootOperations(mainServices, version,
                builder.parseXmlResource("security-manager-reject.xml"),
                new FailedOperationTransformationConfig()
                        .addFailedAttribute(PathAddress.pathAddress(subsystemAddress, PathElement.pathElement(Constants.DEPLOYMENT_PERMISSIONS)),
                                new FailedOperationTransformationConfig.NewAttributesConfig(Constants.MAXIMUM_PERMISSIONS)));
    }
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
private void buildTransformers_2_0(ResourceTransformationDescriptionBuilder builder) {
    final ResourceTransformationDescriptionBuilder xformBuilder = builder.addChildResource(WorkerResourceDefinition.INSTANCE.getPathElement());
    xformBuilder.rejectChildResource(PathElement.pathElement(OutboundBindAddressResourceDefinition.BIND_ADDRESS.getName()));
    xformBuilder.getAttributeBuilder()
            .setValueConverter(
                    new AttributeConverter.DefaultValueAttributeConverter(WorkerResourceDefinition.WORKER_TASK_KEEPALIVE),
                    WorkerResourceDefinition.WORKER_TASK_KEEPALIVE
            )
            .addRejectCheck(RejectAttributeChecker.SIMPLE_EXPRESSIONS,
                    WorkerResourceDefinition.STACK_SIZE,
                    WorkerResourceDefinition.WORKER_IO_THREADS,
                    WorkerResourceDefinition.WORKER_TASK_KEEPALIVE,
                    WorkerResourceDefinition.WORKER_TASK_MAX_THREADS
            )
    ;


}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
@Override
public TransformerEntry resolveTransformerEntry(Iterator<PathElement> iterator) {
    if(!iterator.hasNext()) {
        return getTransformerEntry();
    } else {
        final PathElement element = iterator.next();
        SubRegistry sub = subRegistries.get(element.getKey());
        if(sub == null) {
            return null;
        }
        final ChainedPlaceholderResolver registry = sub.get(element.getValue());
        if(registry == null) {
            return null;
        }
        return registry.resolveTransformerEntry(iterator);
    }
}
 

import org.jboss.as.controller.PathElement; //导入依赖的package包/类
public static String resolveRelativePath(final String relativePath) {
    final ModelNode address = PathAddress.pathAddress(
            PathElement.pathElement(ModelDescriptionConstants.PATH, relativePath)
    ).toModelNode();
    final ModelNode result;
    try {
        final ModelNode op = Operations.createReadAttributeOperation(address, ModelDescriptionConstants.PATH);
        result = client.getControllerClient().execute(op);
        if (Operations.isSuccessfulOutcome(result)) {
            return Operations.readResult(result).asString();
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    throw new RuntimeException(Operations.getFailureDescription(result).asString());
}