Refine search
@Override public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) { if (operation != null && !(operation.hasDefined(OPERATION_HEADERS) && operation.get(OPERATION_HEADERS, "push-to-servers").asBoolean(false)) ){ operation = operation.clone(); String statefulCache = operation.get(DEFAULT_SFSB_CACHE).asString(); String statefulPassivationDisabledCache = operation.get(DEFAULT_SFSB_PASSIVATION_DISABLED_CACHE).asString(); operation.get(DEFAULT_SFSB_CACHE).set(statefulPassivationDisabledCache); operation.get(EJB3SubsystemModel.DEFAULT_CLUSTERED_SFSB_CACHE).set(statefulCache); operation.remove(DEFAULT_SFSB_PASSIVATION_DISABLED_CACHE); } return new TransformedOperation(operation, OperationResultTransformer.ORIGINAL_RESULT); } }
ModelNode operation = originalOperation; for (OperationTransformer transformer: this.transformers) { operation = transformer.transformOperation(context, address, operation).getTransformedOperation(); if (this.collate && operation.get(ModelDescriptionConstants.OP).asString().equals(ModelDescriptionConstants.COMPOSITE)) { List<ModelNode> stepList = operation.get(ModelDescriptionConstants.STEPS).asList(); ListIterator<ModelNode> steps = stepList.listIterator(); while (steps.hasNext()) { String operationName = Operations.getName(step); PathAddress operationAddress = Operations.getPathAddress(step); if (operationName.equals(originalName) && operationAddress.equals(originalAddress)) { operation = step; break; String operationName = Operations.getName(step); PathAddress operationAddress = Operations.getPathAddress(step); if (operationName.equals(originalName) && operationAddress.equals(originalAddress)) { break; return new TransformedOperation(operation, OperationResultTransformer.ORIGINAL_RESULT);
private void testNonMapTransformersWork(KernelServices services, ModelVersion version) throws Exception { final PathAddress stackAddr = PathAddress.pathAddress(SUBSYSTEM, getMainSubsystemName()).append("stack", "test"); ModelNode addStack = Util.createAddOperation(stackAddr); executeOpInBothControllersWithAttachments(services, version, addStack); final PathAddress transportAddr = stackAddr.append("transport", "tcp"); ModelNode addTransport = Util.createAddOperation(transportAddr); addTransport.get(SocketBindingProtocolResourceDefinition.Attribute.SOCKET_BINDING.getName()).set("some-binding"); addTransport.get(MODULE).set("do.reject"); TransformedOperation op = services.executeInMainAndGetTheTransformedOperation(addTransport, version); Assert.assertTrue(op.rejectOperation(success())); final PathAddress protocolAddr = stackAddr.append("protocol", "PING"); ModelNode addProtocol = Util.createAddOperation(protocolAddr); addProtocol.get(MODULE).set("do.reject"); op = services.executeInMainAndGetTheTransformedOperation(addProtocol, version); Assert.assertTrue(op.rejectOperation(success())); op = services.executeInMainAndGetTheTransformedOperation(Util.getWriteAttributeOperation(transportAddr, MODULE, "reject.this"), version); Assert.assertTrue(op.rejectOperation(success())); op = services.executeInMainAndGetTheTransformedOperation(Util.getWriteAttributeOperation(protocolAddr, MODULE, "reject.this"), version); Assert.assertTrue(op.rejectOperation(success())); }
@Override public OperationTransformer.TransformedOperation transformOperation(final TransformationContext context, final ModelNode operation) throws OperationFailedException { final PathAddress address = PathAddress.pathAddress(operation.require(OP_ADDR)); final String operationName = operation.require(OP).asString(); TransformationContext opCtx = ResourceTransformationContextImpl.wrapForOperation(context, operation); final OperationTransformer transformer = target.resolveTransformer(opCtx, address, operationName); if (transformer == null) { ControllerLogger.ROOT_LOGGER.tracef("operation %s does not need transformation", operation); return new OperationTransformer.TransformedOperation(operation, OperationResultTransformer.ORIGINAL_RESULT); } // Transform the path address final PathAddress transformed = transformAddress(address, target); // Update the operation using the new path address operation.get(OP_ADDR).set(transformed.toModelNode()); // TODO should this happen by default? OperationTransformer.TransformedOperation res = transformer.transformOperation(opCtx, transformed, operation); context.getLogger().flushLogQueue(); return res; }
@Override public TransformedOperation transformOperation(final TransformationContext context, final PathAddress address, final ModelNode original) throws OperationFailedException{ final ModelNode operation = original.clone(); final PathAddress transformedAddress = transformer.transformAddress(address); operation.get(ModelDescriptionConstants.OP_ADDR).set(transformedAddress.toModelNode()); // Hand-off to a local operation transformer at the right address final String operationName = operation.get(ModelDescriptionConstants.OP).asString(); final OperationTransformer aliasTransformer = context.getTarget().resolveTransformer(transformedAddress, operationName); if(aliasTransformer != null) { return aliasTransformer.transformOperation(context, transformedAddress, operation); } else { return new TransformedOperation(operation, OperationResultTransformer.ORIGINAL_RESULT); } }
final TransformingProxyController transformingProxyController = (TransformingProxyController) proxyController; final OperationTransformer.TransformedOperation result = transformingProxyController.transformOperation(context, operation); final ModelNode transformedOperation = result.getTransformedOperation(); final OperationResultTransformer resultTransformer = result.getResultTransformer(); if(transformedOperation != null) { final ProxyController.ProxyOperationControl transformingProxyControl = new ProxyController.ProxyOperationControl() { final ModelNode newResponse = new ModelNode(); newResponse.get(OUTCOME).set(FAILED); newResponse.get(FAILURE_DESCRIPTION).set(result.getFailureDescription()); final ModelNode newResponse = new ModelNode(); newResponse.get(OUTCOME).set(FAILED); newResponse.get(FAILURE_DESCRIPTION).set(result.getFailureDescription()); } else { final ModelNode transformedResult = resultTransformer.transformResult(new ModelNode()); if(transformedResult != null) { context.getResult().set(transformedResult);
private ModelNode transformResponse(ModelNode response) { final ModelNode transformed; // Check if we have to reject the operation if(result.rejectOperation(response)) { final ModelNode newResponse = new ModelNode(); newResponse.get(OUTCOME).set(FAILED); newResponse.get(FAILURE_DESCRIPTION).set(result.getFailureDescription()); transformed = newResponse; } else { transformed = response; } return transformed; } };
@Override public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException { if (operation.get(NAME).asString().equals(PROPERTIES)) { InitialAttributeValueOperationContextAttachment attachment = context.getAttachment(InitialAttributeValueOperationContextAttachment.INITIAL_VALUES_ATTACHMENT); assert attachment != null; ModelNode newValue = context.readResourceFromRoot(resolvedAddress).getModel().get(PROPERTIES).clone(); if (initialValue.equals(newValue) || (initialValue.isDefined() && initialValue.asPropertyList().isEmpty() && !newValue.isDefined())) { return new TransformedOperation(null, DEFAULT_REJECTION_POLICY, SUCCESSFUL_RESULT); if (!oldPropValue.equals(value)) { ModelNode writeOp = Util.getWriteAttributeOperation(legacyAddress.append(PathElement.pathElement(PROPERTY, key)), VALUE, value); operations.add(writeOp); ModelNode removeOperation = Util.createRemoveOperation(legacyAddress.append(PathElement.pathElement(PROPERTY, prop.getKey()))); operations.add(removeOperation); initialValue.set(newValue.clone()); return new TransformedOperation(Operations.createCompositeOperation(operations), OperationResultTransformer.ORIGINAL_RESULT); return new TransformedOperation(operation, OperationResultTransformer.ORIGINAL_RESULT);
@Override public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) { if (operation != null && !(operation.hasDefined(OPERATION_HEADERS) && operation.get(OPERATION_HEADERS, "push-to-servers").asBoolean(false)) ){ String originalAttribute = Operations.getAttributeName(operation); if (renames.containsKey(originalAttribute)){ operation = operation.clone(); operation.get(NAME).set(renames.get(originalAttribute)); } } return new TransformedOperation(operation, OperationResultTransformer.ORIGINAL_RESULT); }
@Override public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) { ModelNode legacyOperation = this.transformer.transformOperation(operation); for (Attribute attribute: this.attributes) { String name = attribute.getName(); if (operation.hasDefined(name)) { legacyOperation.get(name).set(operation.get(name)); } } return new TransformedOperation(legacyOperation, OperationResultTransformer.ORIGINAL_RESULT); } }
@Override public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException { ModelNode transformed; if (RemotingEndpointResource.ATTRIBUTES.containsKey(operation.get(NAME).asString())) { transformed = operation.clone(); PathAddress endpointAddress = address.append(RemotingEndpointResource.ENDPOINT_PATH); transformed.get(OP_ADDR).set(endpointAddress.toModelNode()); } else { transformed = operation; } return new TransformedOperation(transformed, OperationResultTransformer.ORIGINAL_RESULT); } }
public TransformedOperation transformOperation(ModelVersion modelVersion, ModelNode operation, TransformerOperationAttachment attachment) throws OperationFailedException { checkIsMainController(); TransformerRegistry transformerRegistry = extensionRegistry.getTransformerRegistry(); PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR)); Map<PathAddress, ModelVersion> subsystemVersions = Collections.<PathAddress, ModelVersion>emptyMap(); OperationTransformerRegistry registry = transformerRegistry.resolveHost(modelVersion, subsystemVersions); TransformationTarget target = TransformationTargetImpl.create(null, extensionRegistry.getTransformerRegistry(), modelVersion, subsystemVersions, TransformationTarget.TransformationTargetType.DOMAIN); TransformationContext transformationContext = createTransformationContext(target, attachment); OperationTransformer operationTransformer = registry.resolveOperationTransformer(address, operation.get(OP).asString(), null).getTransformer(); if (operationTransformer != null) { return operationTransformer.transformOperation(transformationContext, address, operation); } return new OperationTransformer.TransformedOperation(operation, OperationResultTransformer.ORIGINAL_RESULT); }
public TransformedOperation transformOperation(ModelVersion modelVersion, ModelNode operation, TransformerOperationAttachment attachment) throws OperationFailedException { checkIsMainController(); PathElement pathElement = PathElement.pathElement(SUBSYSTEM, mainSubsystemName); PathAddress opAddr = PathAddress.pathAddress(operation.get(OP_ADDR)); // Composite operations have no address if ((opAddr.size() > 0 && opAddr.getElement(0).equals(pathElement)) || operation.get(OP).asString().equals(COMPOSITE)) { final Map<PathAddress, ModelVersion> subsystem = Collections.singletonMap(PathAddress.EMPTY_ADDRESS.append(pathElement), modelVersion); final TransformationTarget transformationTarget = TransformationTargetImpl.create(null, extensionRegistry.getTransformerRegistry(), getCoreModelVersionByLegacyModelVersion(modelVersion), subsystem, TransformationTarget.TransformationTargetType.SERVER); final Transformers transformers = Transformers.Factory.create(transformationTarget); final TransformationContext transformationContext = createTransformationContext(transformationTarget, attachment); return transformers.transformOperation(transformationContext, operation); } return new OperationTransformer.TransformedOperation(operation, OperationResultTransformer.ORIGINAL_RESULT); }
@Override public TransformedOperation transformOperation(final TransformationContext context, final PathAddress address, final ModelNode operation) throws OperationFailedException { Resource original = context.readResourceFromRoot(address); String defaultDataStore = original.getModel().get(TimerServiceResourceDefinition.DEFAULT_DATA_STORE.getName()).asString(); boolean hasFileDataStore = original.hasChild(PathElement.pathElement(EJB3SubsystemModel.FILE_DATA_STORE_PATH.getKey(), defaultDataStore)); if (original.getChildren(EJB3SubsystemModel.FILE_DATA_STORE).size() > 1 || !hasFileDataStore) { return new TransformedOperation(operation, new OperationRejectionPolicy() { @Override public boolean rejectOperation(ModelNode preparedResult) { return true; } @Override public String getFailureDescription() { return context.getLogger().getRejectedResourceWarning(address, operation); } }, OperationResultTransformer.ORIGINAL_RESULT); } operation.get(TimerServiceResourceDefinition.THREAD_POOL_NAME.getName()).set(original.getModel().get(TimerServiceResourceDefinition.THREAD_POOL_NAME.getName())); return new TransformedOperation(operation, OperationResultTransformer.ORIGINAL_RESULT); }
@Override public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException { final String name = operation.require(NAME).asString(); final ModelNode value = operation.get(ModelDescriptionConstants.VALUE); if (SLOT_ATTRIBUTE_NAME.equals(name)) { if (value.isDefined() && value.equals(SLOT_DEFAULT_VALUE)) { return DISCARD.transformOperation(context, address, operation); } else { return new TransformedOperation(operation, new RejectionWithFailurePolicy(MESSAGES.invalidJSFSlotValue(value.asString())), OperationResultTransformer.ORIGINAL_RESULT); } } // reject the operation for any other attribute return new TransformedOperation(operation, new RejectionWithFailurePolicy(MESSAGES.unknownAttributesFromSubsystemVersion(ADD, JSF_SUBSYSTEM, context.getTarget().getSubsystemVersion(JSF_SUBSYSTEM), Arrays.asList(name))), OperationResultTransformer.ORIGINAL_RESULT); } });
@Override public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException { if (operation.hasDefined(SLOT_ATTRIBUTE_NAME)) { ModelNode slot = operation.get(SLOT_ATTRIBUTE_NAME); if (!SLOT_DEFAULT_VALUE.equals(slot.asString())) { return new TransformedOperation(operation, new RejectionWithFailurePolicy(MESSAGES.invalidJSFSlotValue(slot.asString())), OperationResultTransformer.ORIGINAL_RESULT); } } Set<String> attributes = new HashSet<String>(); for (Property prop : operation.asPropertyList()) { attributes.add(prop.getName()); } attributes.remove(SLOT_ATTRIBUTE_NAME); if (!attributes.isEmpty()) { return new TransformedOperation(operation, new RejectionWithFailurePolicy(MESSAGES.unknownAttributesFromSubsystemVersion(ADD, JSF_SUBSYSTEM, context.getTarget().getSubsystemVersion(JSF_SUBSYSTEM), attributes)), OperationResultTransformer.ORIGINAL_RESULT); } return DISCARD.transformOperation(context, address, operation); } });
@Override public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException { PathAddress pathAddress = PathAddress.pathAddress(operation.get(OP_ADDR)); pathAddress = pathAddress.subAddress(0, pathAddress.size() - 1); ModelNode op = Util.getWriteAttributeOperation(pathAddress, CommonAttributes.SHOW_MODEL, new ModelNode(showModel)); return new TransformedOperation(op,OperationResultTransformer.ORIGINAL_RESULT); } }
private static void checkFailedTransformedWriteAttributeOperation(ModelTestKernelServices<?> mainServices, ModelVersion modelVersion, ModelNode operation, FailedOperationTransformationConfig config) throws OperationFailedException { TransformedOperation transformedOperation = mainServices.transformOperation(modelVersion, operation.clone()); if (config.expectFailedWriteAttributeOperation(operation)) { Assert.assertNotNull("Expected transformation to get rejected " + operation, transformedOperation.getFailureDescription()); //For write-attribute we currently only correct once, all in one go checkFailedTransformedWriteAttributeOperation(mainServices, modelVersion, config.correctWriteAttributeOperation(operation), config); } else { ModelNode result = mainServices.executeOperation(modelVersion, transformedOperation); Assert.assertEquals("Failed: " + operation + "\n: " + result, SUCCESS, result.get(OUTCOME).asString()); } }
@Override public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException { ModelNode transformedOp = Util.createEmptyOperation(READ_RESOURCE_OPERATION, address); transformedOp.get(INCLUDE_RUNTIME).set(true); ResultTransformer rt = new ResultTransformer(operation, address); return new TransformedOperation(transformedOp, rt); } };
@Override public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) { PathAddress parentAddress = address.getParent(); ModelNode value = operation.get(Attribute.FACTOR.getName()); ModelNode transformedOperation = Operations.createWriteAttributeOperation(parentAddress, ProxyConfigurationResourceDefinition.DeprecatedAttribute.SIMPLE_LOAD_PROVIDER, value); return new TransformedOperation(transformedOperation, OperationResultTransformer.ORIGINAL_RESULT); } });