@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);
    }
}
 

static void checkNoOtherHandlerWithTheSameName(OperationContext context) throws OperationFailedException {
    final PathAddress address = context.getCurrentAddress();
    final PathAddress parentAddress = address.subAddress(0, address.size() - 1);
    final Resource resource = context.readResourceFromRoot(parentAddress);

    final PathElement element = address.getLastElement();
    final String handlerType = element.getKey();
    final String handlerName = element.getValue();

    for (String otherHandler: HANDLER_TYPES) {
        if (handlerType.equals(otherHandler)) {
            // we need to check other handler types for the same name
            continue;
        }
        final PathElement check = PathElement.pathElement(otherHandler, handlerName);
        if (resource.hasChild(check)) {
            throw DomainManagementLogger.ROOT_LOGGER.handlerAlreadyExists(check.getValue(), parentAddress.append(check));
        }
    }
}
 

@Test
public void testIncludesWithNoOverriddenSubsystems() throws Exception {
    //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 = getSocketBindingGroupAddress("binding-four");
    ModelNode list = new ModelNode().add("binding-three");
    ModelNode op = Util.getWriteAttributeOperation(addr, INCLUDES, list);
    MockOperationContext operationContext = getOperationContextForSocketBindingIncludes(addr, new RootResourceInitializer() {
        @Override
        public void addAdditionalResources(Resource root) {
            Resource subsystemA = Resource.Factory.create();
            root.getChild(PathElement.pathElement(SOCKET_BINDING_GROUP, "binding-three"))
                    .registerChild(PathElement.pathElement(SUBSYSTEM, "a"), subsystemA);

            Resource subsystemB = Resource.Factory.create();
            Resource SocketBindingGroup4 = root.getChild(PathElement.pathElement(SOCKET_BINDING_GROUP, "binding-four"));
            SocketBindingGroup4.registerChild(PathElement.pathElement(SUBSYSTEM, "b"), subsystemB);
        }
    });
    SocketBindingGroupResourceDefinition.createIncludesValidationHandler().execute(operationContext, op);
    operationContext.executeNextStep();
}
 

private void harmonizeModel(ModelVersion modelVersion, ModelNode legacyModel, ModelNode transformed,
                                              PathAddress address, ModelHarmonizer harmonizer) {

    if (address.size() > 0) {
        PathElement pathElement = address.getElement(0);
        if (legacyModel.hasDefined(pathElement.getKey()) && transformed.hasDefined(pathElement.getKey())) {
            ModelNode legacyType = legacyModel.get(pathElement.getKey());
            ModelNode transformedType = transformed.get(pathElement.getKey());
            PathAddress childAddress = address.size() > 1 ? address.subAddress(1) : PathAddress.EMPTY_ADDRESS;
            if (pathElement.isWildcard()) {
                for (String key : legacyType.keys()) {
                    if (transformedType.has(key)) {
                        harmonizeModel(modelVersion, legacyType.get(key),
                                transformedType.get(key), childAddress, harmonizer);
                    }
                }
            } else {
                harmonizeModel(modelVersion, legacyType.get(pathElement.getValue()),
                        transformedType.get(pathElement.getValue()), address, harmonizer);
            }
        }
    } else {
        harmonizer.harmonizeModel(modelVersion, legacyModel, transformed);
    }
}
 

private void doIterate(final Resource current, final PathAddress address) {
    boolean handleChildren = false;

    ObjectName resourceObjectName = action.onAddress(address);
    if (resourceObjectName != null &&
            (accessControlUtil == null || accessControlUtil.getResourceAccess(address, false).isAccessibleResource())) {
        handleChildren = action.onResource(resourceObjectName);
    }

    if (handleChildren) {
        for (String type : current.getChildTypes()) {
            if (current.hasChildren(type)) {
                for (ResourceEntry entry : current.getChildren(type)) {
                    final PathElement pathElement = entry.getPathElement();
                    final PathAddress childAddress = address.append(pathElement);
                    doIterate(entry, childAddress);
                }
            }
        }
    }
}
 

@Override
public ModelNode getProfileOperations(String profileName) {
    ModelNode operation = new ModelNode();

    operation.get(OP).set(DESCRIBE);
    operation.get(OP_ADDR).set(PathAddress.pathAddress(PathElement.pathElement(PROFILE, profileName)).toModelNode());
    operation.get(SERVER_LAUNCH).set(true);

    ModelNode rsp = getValue().execute(operation, null, null, null);
    if (!rsp.hasDefined(OUTCOME) || !SUCCESS.equals(rsp.get(OUTCOME).asString())) {
        ModelNode msgNode = rsp.get(FAILURE_DESCRIPTION);
        String msg = msgNode.isDefined() ? msgNode.toString() : HostControllerLogger.ROOT_LOGGER.failedProfileOperationsRetrieval();
        throw new RuntimeException(msg);
    }
    return rsp.require(RESULT);
}
 

@Test
    public void testFetchFromMasterWithDiscovery() throws URISyntaxException, IOException {
        String hostName = createSecondSlave(AdminOnlyDomainConfigPolicy.FETCH_FROM_MASTER, true, false);
        validateProfiles("default");

        // Now we validate that we can pull down further data if needed
        PathAddress pa = PathAddress.pathAddress(PathElement.pathElement(HOST, hostName), PathElement.pathElement(SERVER_CONFIG, "other1"));
        ModelNode op = Util.createAddOperation(pa);
        op.get(GROUP).set("other-server-group");
        executeForResult(domainSlaveLifecycleUtil.getDomainClient(), op);
        // This should have pulled down the 'other' profile
        validateProfiles("default", "other");

//        ModelNode remove = Util.createRemoveOperation(pa);
//        executeForResult(domainSlaveLifecycleUtil.getDomainClient(), remove);
//
//        // This should have pulled down the 'other' profile
//        validateProfiles("default");
    }
 

/**
 * Creates an alias address by replacing all wildcard values by $ + key so that the address can be used to obtain a capability pattern.
 * @param pa the registration address to be aliased.
 * @return  the aliased address.
 */
private PathAddress createAliasPathAddress(PathAddress pa) {
    ImmutableManagementResourceRegistration registry = registration.getParent();
    List<PathElement> elements = new ArrayList<>();
    for(int i = pa.size() - 1; i >=0; i--) {
        PathElement elt = pa.getElement(i);
        ImmutableManagementResourceRegistration childRegistration = registry.getSubModel(PathAddress.pathAddress(PathElement.pathElement(elt.getKey())));
        if(childRegistration == null) {
            elements.add(elt);
        } else {
            elements.add(PathElement.pathElement(elt.getKey(), "$" + elt.getKey()));
        }
        registry = registry.getParent();
    }
    Collections.reverse(elements);
    return PathAddress.pathAddress(elements.toArray(new PathElement[elements.size()]));
}
 

private void resolvePathTransformers(Iterator<PathElement> iterator, List<PathAddressTransformer> list, PlaceholderResolver placeholderResolver) {
    if(iterator.hasNext()) {
        final PathElement element = iterator.next();
        SubRegistry sub = subRegistriesUpdater.get(this, element.getKey());
        if(sub != null) {
            final OperationTransformerRegistry reg = sub.get(element.getValue());
            if(reg != null) {
                list.add(reg.getPathAddressTransformer());
                if (reg.isPlaceholder() && placeholderResolver != null) {
                    placeholderResolver.resolvePathTransformers(iterator, list);
                } else {
                    reg.resolvePathTransformers(iterator, list, placeholderResolver);
                }
                return;
            }
        }
        list.add(PathAddressTransformer.DEFAULT);
        return;
    }
}
 

private boolean ignoreSocketBindingGroups(final Resource domainResource, final Collection<ServerConfigInfo> serverConfigs, final String name) {
    Set<String> seenGroups = new HashSet<>();
    Set<String> socketBindingGroups = new HashSet<>();
    for (ServerConfigInfo serverConfig : serverConfigs) {
        final String socketBindingGroup;
        if (serverConfig.getSocketBindingGroup() != null) {
            if (serverConfig.getSocketBindingGroup().equals(name)) {
                return false;
            }
            socketBindingGroup = serverConfig.getSocketBindingGroup();
        } else {
            if (seenGroups.contains(serverConfig.getServerGroup())) {
                continue;
            }
            seenGroups.add(serverConfig.getServerGroup());
            Resource serverGroupResource = domainResource.getChild(PathElement.pathElement(SERVER_GROUP, serverConfig.getServerGroup()));
            socketBindingGroup = serverGroupResource.getModel().get(SOCKET_BINDING_GROUP).asString();
            if (socketBindingGroup.equals(name)) {
                return false;
            }
        }
        processSocketBindingGroups(domainResource, socketBindingGroup, socketBindingGroups);
    }
    return !socketBindingGroups.contains(name);
}
 

@Override
protected void initializeExtraSubystemsAndModel(ExtensionRegistry extensionRegistry, Resource rootResource,
                                ManagementResourceRegistration rootRegistration, RuntimeCapabilityRegistry capabilityRegistry) {
    super.initializeExtraSubystemsAndModel(extensionRegistry, rootResource, rootRegistration, capabilityRegistry);

    Resource coreManagement = Resource.Factory.create();
    rootResource.registerChild(CoreManagementResourceDefinition.PATH_ELEMENT, coreManagement);
    Resource auditLog = Resource.Factory.create();
    coreManagement.registerChild(AccessAuditResourceDefinition.PATH_ELEMENT, auditLog);

    Resource testFileHandler = Resource.Factory.create();
    testFileHandler.getModel().setEmptyObject();
    auditLog.registerChild(PathElement.pathElement(FILE_HANDLER, "test"), testFileHandler);

}
 

private static String findSubsystemName(PathAddress pathAddress) {
    for (PathElement element : pathAddress) {
        if (element.getKey().equals(SUBSYSTEM)) {
            return element.getValue();
        }
    }
    return null;
}
 

Set<String> pullDownContent(final Resource domainRootResource) {
    // Make sure we have all needed deployment and management client content
    for (final String id : relevantDeployments) {
        final Set<ContentReference> hashes = deploymentHashes.remove(id);
        if (hashes != null) {
            requiredContent.addAll(hashes);
        }
    }
    for (final ContentReference reference : requiredContent) {
        parameters.getFileRepository().getDeploymentFiles(reference);
        parameters.getContentRepository().addContentReference(reference);
    }

    if (updateRolloutPlans) {
        final PathElement rolloutPlansElement = PathElement.pathElement(MANAGEMENT_CLIENT_CONTENT, ROLLOUT_PLANS);
        final Resource existing = domainRootResource.removeChild(rolloutPlansElement);
        if (existing != null) {
            final ModelNode hashNode = existing.getModel().get(HASH);
            if (hashNode.isDefined()) {
                removedContent.add(
                        new ContentReference(PathAddress.pathAddress(rolloutPlansElement).toCLIStyleString(), hashNode.asBytes()));
            }
        }
        ManagedDMRContentTypeResource rolloutPlansResource =
                new ManagedDMRContentTypeResource(PathAddress.pathAddress(rolloutPlansElement), ROLLOUT_PLAN,
                        rolloutPlansHash, parameters.getContentRepository());
        domainRootResource.registerChild(rolloutPlansElement, rolloutPlansResource);
    }

    final Set<String> servers = new HashSet<>();
    for (String group : affectedGroups) {
        if (serversByGroup.containsKey(group)) {
            servers.addAll(serversByGroup.get(group));
        }
    }
    return servers;
}
 

public static Model readModel(final ImmutableManagementResourceRegistration def, final PathAddress address) {
    Model res = new Model(address);
    Set<String> attributesList = def.getAttributeNames(PathAddress.EMPTY_ADDRESS);

    for (String name : attributesList) {
        res.addAttribute(name);
    }
    for (PathElement element : def.getChildAddresses(PathAddress.EMPTY_ADDRESS)) {
        final ImmutableManagementResourceRegistration child = def.getSubModel(PathAddress.pathAddress(element));
        if (child != null) {
            res.addChild(readModel(child, address.append(element)));
        }
    }
    return res;
}
 

private BoundedQueueThreadPoolResourceDefinition(boolean blocking, boolean registerRuntimeOnly, PathElement path,
                                                   RuntimeCapability<Void> capability, ServiceName serviceNameBase,
                                                   String resolverPrefix, OperationStepHandler addHandler,
                                                   OperationStepHandler removeHandler) {
    super(new SimpleResourceDefinition.Parameters(path, new ThreadPoolResourceDescriptionResolver(resolverPrefix,
                                                  ThreadsExtension.RESOURCE_NAME, ThreadsExtension.class.getClassLoader()))
            .setAddHandler(addHandler)
            .setRemoveHandler(removeHandler)
            .setCapabilities(capability));
    this.registerRuntimeOnly = registerRuntimeOnly;
    this.blocking = blocking;
    metricsHandler = new BoundedQueueThreadPoolMetricsHandler(capability, serviceNameBase);
    writeHandler = new BoundedQueueThreadPoolWriteAttributeHandler(blocking, capability, serviceNameBase);
}
 

private ChainedPlaceholderResolver resolveChild(final Iterator<PathElement> iterator) {

        if(! iterator.hasNext()) {
            return this;
        } else {
            final PathElement element = iterator.next();
            SubRegistry sub = subRegistries.get(element.getKey());
            if(sub == null) {
                return null;
            }
            return sub.get(element.getValue(), iterator);
        }
    }
 

@Override
public void processChild(final PathElement element, Resource child) throws OperationFailedException {
    final PathAddress childAddress = read.append(element); // read
    final TransformerEntry entry = resolveTransformerEntry(childAddress);
    final PathAddressTransformer path = entry.getPathTransformation();
    final PathAddress currentAddress = path.transform(element, new PathAddressTransformer.Builder() { // write
        @Override
        public PathAddress getOriginal() {
            return childAddress;
        }

        @Override
        public PathAddress getCurrent() {
            return current;
        }

        @Override
        public PathAddress getRemaining() {
            return PathAddress.EMPTY_ADDRESS.append(element);
        }

        @Override
        public PathAddress next(PathElement... elements) {
            return current.append(elements);
        }
    });
    final ResourceTransformer transformer = resolveTransformer(entry, childAddress);
    final ResourceTransformationContext childContext =
            new ResourceTransformationContextImpl(root, currentAddress, childAddress, originalModel,
                    transformerOperationAttachment, ignoredTransformationRegistry);
    transformer.transformResource(childContext, currentAddress, child);
}
 

Map<PathElement, Node> getRemoteChildrenOfType(String type) {
    Map<PathElement, Node> map = remote.childrenByType.get(type);
    if (map != null) {
        return map;
    }
    return Collections.emptyMap();
}
 

protected AbstractHandlerDefinition(final PathElement path,
                                    final Class<? extends Handler> type,
                                    final AttributeDefinition[] attributes,
                                    final ConfigurationProperty<?>... constructionProperties) {
    this(createParameters(path, type, PropertySorter.NO_OP, attributes, constructionProperties),
            true, PropertySorter.NO_OP, null, attributes);
}
 

@Override
public Resource removeChild(PathElement address) {
    final Resource toRemove = getChild(address);
    if (toRemove != null) {
        synchronized (content) {
            content.remove(address.getValue());
        }
        try{
            storeContent();
        } catch (IOException e) {
            throw new ContentStorageException(e);
        }
    }
    return toRemove;
}
 

@Override
public Resource requireChild(PathElement address) {
    final Resource resource = getChild(address);
    if (resource == null) {
        throw new NoSuchResourceException(address);
    }
    return resource;
}
 

private boolean isWFCORE621Needed(ImmutableManagementResourceRegistration registration, PathAddress remaining) {
    if (remaining.size() > 0) {
        PathElement pe = remaining.getElement(0);
        if (pe.isMultiTarget() && RUNNING_SERVER.equals(pe.getKey())) {
            // We only need this for WildFly 8 and earlier (including EAP 6),
            // so that's proxied controllers running kernel version 1.x or 2.x
            ModelVersion modelVersion = registration.getProxyController(PathAddress.EMPTY_ADDRESS).getKernelModelVersion();
            return modelVersion.getMajor() < 3;
        }
    }
    return false;
}
 

/**
 * Test of getNameFromAddress method, of class Util.
 */
@Test
public void testGetNameFromAddress_PathAddress() {
    System.out.println("getNameFromAddress");
    PathAddress address = PathAddress.EMPTY_ADDRESS;
    assertThat(Util.getNameFromAddress(address), is(nullValue()));
    address = PathAddress.pathAddress(PathElement.pathElement("subsystem"));
    assertThat(Util.getNameFromAddress(address), is(PathElement.WILDCARD_VALUE));
    address = PathAddress.pathAddress("subsystem", "test");
    assertThat(Util.getNameFromAddress(address), is("test"));
}
 

@Test
public void testIncludesWithOverriddenSocketBindings() 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 = getSocketBindingGroupAddress("binding-four");
        ModelNode list = new ModelNode().add("binding-three");
        ModelNode op = Util.getWriteAttributeOperation(addr, INCLUDES, list);
        MockOperationContext operationContext = getOperationContextForSocketBindingIncludes(addr, new RootResourceInitializer() {
            @Override
            public void addAdditionalResources(Resource root) {
                Resource subsystemA = Resource.Factory.create();
                root.getChild(PathElement.pathElement(SOCKET_BINDING_GROUP, "binding-three"))
                        .registerChild(PathElement.pathElement(SOCKET_BINDING, "a"), subsystemA);

                Resource subsystemB = Resource.Factory.create();
                Resource SocketBindingGroup4 = root.getChild(PathElement.pathElement(SOCKET_BINDING_GROUP, "binding-four"));
                SocketBindingGroup4.registerChild(PathElement.pathElement(SOCKET_BINDING, "a"), subsystemB);
            }
        });
        SocketBindingGroupResourceDefinition.createIncludesValidationHandler().execute(operationContext, op);
        operationContext.executeNextStep();
        Assert.fail("Expected error");
    } catch (OperationFailedException expected) {
        Assert.assertTrue(expected.getMessage().contains("166"));
        Assert.assertTrue(expected.getMessage().contains("'binding-four'"));
        Assert.assertTrue(expected.getMessage().contains("'binding-three'"));
        Assert.assertTrue(expected.getMessage().contains("'a'"));
    }
}
 

@Override
public ManagementResourceRegistration registerSubModel(final ResourceDefinition resourceDefinition) {
    Assert.checkNotNullParam("resourceDefinition", resourceDefinition);
    final PathElement address = resourceDefinition.getPathElement();
    if (address == null) {
        throw ControllerLogger.ROOT_LOGGER.cannotRegisterSubmodelWithNullPath();
    }
    final ManagementResourceRegistration existing = getSubRegistration(PathAddress.pathAddress(address));
    if (existing != null && existing.getPathAddress().getLastElement().getValue().equals(address.getValue())) {
        throw ControllerLogger.ROOT_LOGGER.nodeAlreadyRegistered(existing.getPathAddress().toCLIStyleString());
    }
    final NodeSubregistry child = getOrCreateSubregistry(address.getKey());
    return child.registerChild(address.getValue(), resourceDefinition);
}
 

private ManagedDMRContentResourceDefinition(final String childType,
                                           final AttributeDefinition contentDefinition,
                                           final ResourceDescriptionResolver descriptionResolver) {
    super(PathElement.pathElement(childType),
            descriptionResolver,
            null,
            ManagedDMRContentRemoveHandler.INSTANCE,
            OperationEntry.Flag.RESTART_NONE, OperationEntry.Flag.RESTART_NONE);
    this.contentDefinition = contentDefinition;
}
 

private SimpleRegexRealmMapperDefinition() {
    super(new Parameters(PathElement.pathElement(ElytronDescriptionConstants.SIMPLE_REGEX_REALM_MAPPER), ElytronExtension.getResourceDescriptionResolver(ElytronDescriptionConstants.SIMPLE_REGEX_REALM_MAPPER))
        .setAddHandler(ADD)
        .setRemoveHandler(REMOVE)
        .setAddRestartLevel(OperationEntry.Flag.RESTART_RESOURCE_SERVICES)
        .setRemoveRestartLevel(OperationEntry.Flag.RESTART_RESOURCE_SERVICES)
        .setCapabilities(REALM_MAPPER_RUNTIME_CAPABILITY));
}
 

private PathAddress getIdpPath() {
    return PathAddress.EMPTY_ADDRESS
            .append(PathElement.pathElement(ModelDescriptionConstants.SUBSYSTEM, KeycloakSamlExtension.SUBSYSTEM_NAME))
            .append(PathElement.pathElement(Constants.Model.SECURE_DEPLOYMENT, "my-app.war"))
            .append(PathElement.pathElement(Constants.Model.SERVICE_PROVIDER, "http://localhost:8080/sales-post-enc/"))
            .append(PathElement.pathElement(Constants.Model.IDENTITY_PROVIDER, "idp"));
}
 

/**
 * Determine the relevant pieces of configuration which need to be included when processing the domain model.
 *
 * @param root                 the resource root
 * @param requiredConfigurationHolder    the resolution context
 * @param serverConfig         the server config
 * @param extensionRegistry    the extension registry
 */
static void processServerConfig(final Resource root, final RequiredConfigurationHolder requiredConfigurationHolder, final IgnoredNonAffectedServerGroupsUtil.ServerConfigInfo serverConfig, final ExtensionRegistry extensionRegistry) {

    final Set<String> serverGroups = requiredConfigurationHolder.serverGroups;
    final Set<String> socketBindings = requiredConfigurationHolder.socketBindings;

    String sbg = serverConfig.getSocketBindingGroup();
    if (sbg != null && !socketBindings.contains(sbg)) {
        processSocketBindingGroup(root, sbg, requiredConfigurationHolder);
    }

    final String groupName = serverConfig.getServerGroup();
    final PathElement groupElement = PathElement.pathElement(SERVER_GROUP, groupName);
    // Also check the root, since this also gets executed on the slave which may not have the server-group configured yet
    if (!serverGroups.contains(groupName) && root.hasChild(groupElement)) {

        final Resource serverGroup = root.getChild(groupElement);
        final ModelNode groupModel = serverGroup.getModel();
        serverGroups.add(groupName);

        // Include the socket binding groups
        if (groupModel.hasDefined(SOCKET_BINDING_GROUP)) {
            final String socketBindingGroup = groupModel.get(SOCKET_BINDING_GROUP).asString();
            processSocketBindingGroup(root, socketBindingGroup, requiredConfigurationHolder);
        }

        final String profileName = groupModel.get(PROFILE).asString();
        processProfile(root, profileName, requiredConfigurationHolder, extensionRegistry);
    }
}
 

SSLSessionDefinition(boolean server) {
    super(new Parameters(PathElement.pathElement(ElytronDescriptionConstants.SSL_SESSION), RESOURCE_DESCRIPTION_RESOLVER)
        .setAddRestartLevel(OperationEntry.Flag.RESTART_NONE)
        .setRemoveRestartLevel(OperationEntry.Flag.RESTART_RESOURCE_SERVICES)
        .setRuntime());
    this.server = server;
}