Refine search
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { if (resource.hasChild(SimpleLoadProviderResourceDefinition.PATH)) { ModelNode model = resource.getModel(); ModelNode simpleModel = Resource.Tools.readModel(resource.removeChild(SimpleLoadProviderResourceDefinition.PATH)); model.get(DeprecatedAttribute.SIMPLE_LOAD_PROVIDER.getName()).set(simpleModel.get(SimpleLoadProviderResourceDefinition.Attribute.FACTOR.getName())); } context.addTransformedResource(PathAddress.EMPTY_ADDRESS, resource).processChildren(resource); } });
/** * {@inheritDoc} */ @Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { context.addTransformedResourceFromRoot(this.addressTransformer.transform(address), resource).processChildren(resource); } }
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { Resource untransformedResource = context.readResource(PathAddress.EMPTY_ADDRESS); ModelNode untransformedModel = Resource.Tools.readModel(untransformedResource); String statefulCache = untransformedModel.get(DEFAULT_SFSB_CACHE).asString(); String statefulPassivationDisabledCache = untransformedModel.get(DEFAULT_SFSB_PASSIVATION_DISABLED_CACHE).asString(); ModelNode transformed = resource.getModel(); transformed.get(DEFAULT_SFSB_CACHE).set(statefulPassivationDisabledCache); transformed.get(EJB3SubsystemModel.DEFAULT_CLUSTERED_SFSB_CACHE).set(statefulCache); transformed.remove(DEFAULT_SFSB_PASSIVATION_DISABLED_CACHE); final ResourceTransformationContext childContext = context.addTransformedResource(PathAddress.EMPTY_ADDRESS, resource); childContext.processChildren(resource); } }
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { final ModelNode model = resource.getModel(); final ModelNode properties = model.remove(PROPERTIES); final ResourceTransformationContext parentContext = context.addTransformedResourceFromRoot(address, resource); transformPropertiesToChildrenResources(properties, address, parentContext); context.processChildren(resource); }
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { ModelNode model = resource.getModel(); //The existance of the expose-model=>resolved child is translated into the show-model=>true attribute Resource exposeResolvedResource = resource.getChild(PathElement.pathElement(CommonAttributes.EXPOSE_MODEL, CommonAttributes.RESOLVED)); boolean showModel = false; if (exposeResolvedResource != null) { showModel = model.isDefined(); } model.get(CommonAttributes.SHOW_MODEL).set(showModel); ResourceTransformationContext childContext = context.addTransformedResource(PathAddress.EMPTY_ADDRESS, resource); //Process all the child resources skipping the expose-model=>* children for (String type :resource.getChildTypes()) { if (!type.equals(CommonAttributes.EXPOSE_MODEL)) { for (ResourceEntry child : resource.getChildren(type)) { childContext.processChild(child.getPathElement(), child); } } } } });
@Override public void transformResource(final ResourceTransformationContext context, final PathAddress address, final Resource resource) throws OperationFailedException { // Check the model final ModelNode model = resource.getModel(); final Set<String> attributes = checkModel(model, context); if (attributes.size() > 0) { if (context.getTarget().isIgnoredResourceListAvailableAtRegistration()) { // Slave is 7.2.x or higher and we know this resource is not ignored List<String> msg = Collections.singletonList(context.getLogger().getAttributeWarning(address, null, ControllerLogger.ROOT_LOGGER.attributesDontSupportExpressions(), attributes)); final TransformationTarget tgt = context.getTarget(); final String legacyHostName = tgt.getHostName(); final ModelVersion coreVersion = tgt.getVersion(); final String subsystemName = findSubsystemName(address); final ModelVersion usedVersion = subsystemName == null ? coreVersion : tgt.getSubsystemVersion(subsystemName); // Target is 7.2.x or higher so we should throw an error if (subsystemName != null) { throw ControllerLogger.ROOT_LOGGER.rejectAttributesSubsystemModelResourceTransformer(address, legacyHostName, subsystemName, usedVersion, msg); } throw ControllerLogger.ROOT_LOGGER.rejectAttributesCoreModelResourceTransformer(address, legacyHostName, usedVersion, msg); } else { // 7.1.x slave; resource *may* be ignored so we can't fail; just log context.getLogger().logAttributeWarning(address, ControllerLogger.ROOT_LOGGER.attributesDontSupportExpressions(), attributes); } } final ResourceTransformationContext childContext = context.addTransformedResource(PathAddress.EMPTY_ADDRESS, resource); childContext.processChildren(resource); }
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { for (String name : resource.getChildrenNames(ProtocolResourceDefinition.WILDCARD_PATH.getKey())) { resource.getModel().get(PROTOCOLS.getName()).add(name); } context.addTransformedResource(PathAddress.EMPTY_ADDRESS, resource).processChildren(resource); } };
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { ModelNode model = resource.getModel(); if (model.hasDefined(Attribute.MODE.getName())) { ModelNode value = model.get(Attribute.MODE.getName()); if ((value.getType() == ModelType.STRING) && (TransactionMode.valueOf(value.asString()) == TransactionMode.BATCH)) { value.set(TransactionMode.NONE.name()); } } context.addTransformedResource(PathAddress.EMPTY_ADDRESS, resource).processChildren(resource); } };
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { PathAddress transactionAddress = address.append(TransactionResourceDefinition.PATH); try { ModelNode transaction = context.readResourceFromRoot(transactionAddress).getModel(); if (transaction.hasDefined(TransactionResourceDefinition.Attribute.MODE.getName())) { ModelNode mode = transaction.get(TransactionResourceDefinition.Attribute.MODE.getName()); if ((mode.getType() == ModelType.STRING) && (TransactionMode.valueOf(mode.asString()) == TransactionMode.BATCH)) { resource.getModel().get(DeprecatedAttribute.BATCHING.getName()).set(true); } } } catch (NoSuchElementException e) { // Ignore, nothing to convert } context.addTransformedResource(PathAddress.EMPTY_ADDRESS, resource).processChildren(resource); } };
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { ModelNode model = resource.getModel(); if (model.hasDefined(SLOT_ATTRIBUTE_NAME)) { ModelNode slot = model.get(SLOT_ATTRIBUTE_NAME); if (!SLOT_DEFAULT_VALUE.equals(slot.asString())) { context.getLogger().logAttributeWarning(address, MESSAGES.invalidJSFSlotValue(slot.asString()), SLOT_ATTRIBUTE_NAME); } } Set<String> attributes = new HashSet<String>(); for (Property prop : resource.getModel().asPropertyList()) { attributes.add(prop.getName()); } attributes.remove(SLOT_ATTRIBUTE_NAME); if (!attributes.isEmpty()) { context.getLogger().logAttributeWarning(address, ControllerMessages.MESSAGES.attributesAreNotUnderstoodAndMustBeIgnored(), attributes); } } });
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { if (resource.isProxy() || resource.isRuntime()) { return; } final ResourceTransformationContext childContext = context.addTransformedResource(PathAddress.EMPTY_ADDRESS, resource); childContext.processChildren(resource); } };
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { Resource untransformedResource = context.readResource(PathAddress.EMPTY_ADDRESS); ModelNode untransformedModel = Resource.Tools.readModel(untransformedResource); String defaultDataStore = untransformedModel.get(TimerServiceResourceDefinition.DEFAULT_DATA_STORE.getName()).asString(); ModelNode transformed = resource.getModel(); transformed.remove(TimerServiceResourceDefinition.DEFAULT_DATA_STORE.getName()); ModelNode fileStore = untransformedModel.get(EJB3SubsystemModel.FILE_DATA_STORE, defaultDataStore); if (!fileStore.isDefined()) {//happens where default is not file-store rejectIncompatibleDataStores(context, address); } else if ((untransformedModel.hasDefined(EJB3SubsystemModel.DATABASE_DATA_STORE) && untransformedModel.get(EJB3SubsystemModel.DATABASE_DATA_STORE).keys().size() > 0) || untransformedModel.get(EJB3SubsystemModel.FILE_DATA_STORE).keys().size() > 1) { rejectIncompatibleDataStores(context, address); } ModelNode path = fileStore.get(EJB3SubsystemModel.PATH); transformed.get(EJB3SubsystemModel.PATH).set(path); transformed.get(EJB3SubsystemModel.RELATIVE_TO).set(fileStore.get(EJB3SubsystemModel.RELATIVE_TO)); context.addTransformedResource(PathAddress.EMPTY_ADDRESS, resource); //do not process children! }
public ResourceTransformationContext copyAndReplaceOriginalModel(PlaceholderResolver placeholderResolver) { assert originalModel.target instanceof TransformationTargetImpl : "Wrong target"; TransformationTargetImpl tgt = (TransformationTargetImpl)originalModel.target; TransformationTargetImpl targetCopy = tgt.copyWithplaceholderResolver(placeholderResolver); final OriginalModel originalModelCopy = new OriginalModel(root, originalModel.mode, originalModel.type, targetCopy, originalModel.registration); ResourceTransformationContext copy = new ResourceTransformationContextImpl(this, originalModelCopy); Resource root = copy.getTransformedRoot(); if (current.size() > 0) { PathElement last = current.getLastElement(); Resource parent = root; for (PathElement element : current) { if (element.equals(last)) { parent.removeChild(element); } else { parent = parent.getChild(element); if (parent == null) { break; } } } } return copy; }
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { transformResourceInt(context, address, resource); final ResourceTransformationContext childContext = context.addTransformedResource(PathAddress.EMPTY_ADDRESS, resource); childContext.processChildren(resource); }
@Override public void transformResource(ResourceTransformationContext context, PathAddress address, Resource resource) throws OperationFailedException { ModelNode model = new ModelNode(); transformModulesToAttributes(address, resourceName, oldName, context, model); resource.writeModel(model); final ResourceTransformationContext childContext = context.addTransformedResource(PathAddress.EMPTY_ADDRESS, resource); childContext.processChildren(resource); }
@Override public void transformResource(final ResourceTransformationContext context, final PathAddress address, final Resource resource) throws OperationFailedException { if (resource.isProxy() || resource.isRuntime()) { return; } //For now just assume we come in through the top layer ResourceTransformationContext current = context; Iterator<Map.Entry<ModelVersionPair, ChainedPlaceholderResolver>> it = placeholderResolvers.entrySet().iterator(); if (it.hasNext()) { ChainedPlaceholderResolver resolver = it.next().getValue(); current = ChainedTransformationTools.initialiseChain(current, resolver); resolver.getDescription().getResourceTransformer().transformResource(current, address, resource); } while (it.hasNext()) { ChainedPlaceholderResolver resolver = it.next().getValue(); current = ChainedTransformationTools.nextInChainResource(current, resolver); try { Resource currentResource = current.readResourceFromRoot(address); resolver.getDescription().getResourceTransformer().transformResource(current, address, currentResource); } catch (Resource.NoSuchResourceException e) { //The resource was rejected/discarded continue; } } Resource transformed = current.getTransformedRoot(); Resource originalTransformed = context.getTransformedRoot(); copy(transformed, originalTransformed, address); }
@Override public Resource transformResource(final ResourceTransformationContext context, Resource resource) throws OperationFailedException { final ResourceTransformer transformer = target.resolveTransformer(PathAddress.EMPTY_ADDRESS); if (transformer == null) { ControllerLogger.ROOT_LOGGER.tracef("resource %s does not need transformation", resource); return resource; } transformer.transformResource(context, PathAddress.EMPTY_ADDRESS, resource); context.getLogger().flushLogQueue(); return context.getTransformedRoot(); }
private PathAddress transformAddress(final PathAddress original, final ResourceTransformationContext context) { return ChainedTransformationTools.transformAddress(original, context.getTarget()); }
@Override public void transformResource(final ResourceTransformationContext ctx, final PathAddress address, final Resource original) throws OperationFailedException { final DiscardPolicy discardPolicy = determineDiscardPolicy(ctx, address); switch (discardPolicy) { case REJECT_AND_WARN: ctx.getLogger().logRejectedResourceWarning(address, null); return; case DISCARD_AND_WARN: // don't return yet, just log a warning first and then discard ctx.getLogger().logDiscardedResourceWarning(address, ctx.getTarget().getHostName()); case SILENT: ResourceTransformer.DISCARD.transformResource(ctx, address, original); return; } final Iterator<TransformationRule> iterator = rules.iterator(); final TransformationRule.ChainedResourceContext context = new TransformationRule.ChainedResourceContext(ctx) { @Override void invokeNext(final Resource resource) throws OperationFailedException { if(iterator.hasNext()) { final TransformationRule next = iterator.next(); next.transformResource(resource, address, this); } else { resourceTransformer.transformResource(ctx, address, resource); } } }; // Kick off the chain final TransformationRule rule = new AttributeTransformationRule(attributeTransformations); rule.transformResource(original, address, context); }
@Override public void transformResource(final ResourceTransformationContext context, final PathAddress address, final Resource resource) { // Transform the model recursively final ModelNode recursive = Resource.Tools.readModel(resource); final ModelNode result = transformModel(context, recursive); // Create the target registration based on the old resource definition final TransformationTarget target = context.getTarget(); final ResourceDefinition definition = loader.load(target); final ManagementResourceRegistration targetDefinition = ManagementResourceRegistration.Factory.create(definition); final Resource transformed = TransformationUtils.modelToResource(address, targetDefinition, result, false); // Add the model recursively context.addTransformedRecursiveResource(PathAddress.EMPTY_ADDRESS, transformed); }