@Override public void execute(OperationContext context, ModelNode operation) throws OperationFailedException { ModelNode operationModel = new ModelNode(); populateModel(operation, operationModel); String attributeName = NAME.resolveModelAttribute(context, operationModel).asString(); final ImmutableManagementResourceRegistration registry = context.getResourceRegistration(); final boolean useEnhancedSyntax = containsEnhancedSyntax(attributeName, registry); String attributeExpression = attributeName; if (useEnhancedSyntax) { attributeName = extractAttributeName(attributeName); } final AttributeAccess attributeAccess = context .getResourceRegistration() .getAttributeAccess(PathAddress.EMPTY_ADDRESS, attributeName); if (attributeAccess == null) { throw new OperationFailedException( ControllerLogger.ROOT_LOGGER.unknownAttribute(attributeName)); } final PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR)); final ModelNode readResponse = new ModelNode(); // prepare write operation ModelNode writeOperation = Util.createOperation(WriteAttributeHandler.DEFINITION, address); writeOperation.get(NAME.getName()).set(useEnhancedSyntax ? attributeExpression : attributeName); ModelNode writeOperationValue = writeOperation.get( ModelDescriptionConstants.VALUE); // value will be set in modification step if (attributeAccess.getStorageType() == AttributeAccess.Storage.CONFIGURATION) { // Steps need to be performed before any other steps, so they are added in opposite order // with addFirst=true parameter. // 2. modify value and register writing step context.addStep( (context1, operation1) -> { updateModel( context, operationModel, attributeAccess.getAttributeDefinition(), readResponse.get(RESULT)); // add write step if (requiredReadWriteAccess) { writeOperationValue.set(readResponse.get(RESULT)); context.addStep( writeOperation, WriteAttributeHandler.INSTANCE, OperationContext.Stage.MODEL, true); } }, OperationContext.Stage.MODEL, true); // 1. read current attribute value ModelNode readAttributeOperation = Util.getReadAttributeOperation( address, useEnhancedSyntax ? attributeExpression : attributeName); context.addStep( readResponse, readAttributeOperation, ReadAttributeHandler.INSTANCE, OperationContext.Stage.MODEL, true); } else { assert attributeAccess.getStorageType() == AttributeAccess.Storage.RUNTIME; // For Storage.RUNTIME attributes, attributes need to be registered with reader and writer // step handlers, // which must postpone reading / writing to RUNTIME stage (by registering new RUNTIME steps // which will // perform actual reading / writing). // Steps need to be performed before any other steps, so they are added in opposite order // with addFirst=true parameter. // 3. write modified value if (requiredReadWriteAccess) { context.addStep( readResponse, writeOperation, WriteAttributeHandler.INSTANCE, OperationContext.Stage.MODEL, true); } // 2. modify value context.addStep( (context1, operation1) -> { context.addStep( (context2, operation2) -> { updateModel( context2, operationModel, attributeAccess.getAttributeDefinition(), readResponse.get(RESULT)); writeOperationValue.set(readResponse.get(RESULT)); }, OperationContext.Stage.RUNTIME); }, OperationContext.Stage.MODEL, true); // 1. read current attribute value ModelNode readAttributeOperation = Util.getReadAttributeOperation( address, useEnhancedSyntax ? attributeExpression : attributeName); context.addStep( readResponse, readAttributeOperation, ReadAttributeHandler.INSTANCE, OperationContext.Stage.MODEL, true); } }
@Override public void execute(OperationContext context, ModelNode operation) throws OperationFailedException { NAME.validateOperation(operation); final ModelNode nameModel = GlobalOperationAttributes.NAME.resolveModelAttribute(context, operation); final PathAddress address = context.getCurrentAddress(); final ImmutableManagementResourceRegistration registry = context.getResourceRegistration(); if (registry == null) { throw new OperationFailedException(ControllerLogger.ROOT_LOGGER.noSuchResourceType(address)); } final boolean useEnhancedSyntax = containsEnhancedSyntax(nameModel.asString(), registry); final String attributeName; final String attributeExpression; if (useEnhancedSyntax) { attributeExpression = nameModel.asString(); attributeName = extractAttributeName(nameModel.asString()); } else { attributeName = nameModel.asString(); attributeExpression = attributeName; } final AttributeAccess attributeAccess = registry.getAttributeAccess(PathAddress.EMPTY_ADDRESS, attributeName); if (attributeAccess == null) { throw new OperationFailedException( ControllerLogger.ROOT_LOGGER.unknownAttribute(attributeName)); } else if (attributeAccess.getAccessType() != AttributeAccess.AccessType.READ_WRITE) { throw new OperationFailedException( ControllerLogger.ROOT_LOGGER.attributeNotWritable(attributeName)); } else { // Authorize ModelNode currentValue; if (attributeAccess.getStorageType() == AttributeAccess.Storage.CONFIGURATION) { ModelNode model = context.readResourceForUpdate(PathAddress.EMPTY_ADDRESS).getModel(); currentValue = model.has(attributeName) ? model.get(attributeName) : new ModelNode(); } else { currentValue = new ModelNode(); } AuthorizationResult authorizationResult = context.authorize(operation, attributeName, currentValue); if (authorizationResult.getDecision() == AuthorizationResult.Decision.DENY) { throw ControllerLogger.ROOT_LOGGER.unauthorized( operation.require(OP).asString(), address, authorizationResult.getExplanation()); } if (attributeAccess.getStorageType() == AttributeAccess.Storage.CONFIGURATION && !registry.isRuntimeOnly()) { // if the attribute is stored in the configuration, we can read its // old and new value from the resource's model before and after executing its write handler final ModelNode oldValue = currentValue.clone(); doExecuteInternal( context, operation, attributeAccess, attributeName, currentValue, useEnhancedSyntax, attributeExpression); ModelNode model = context.readResource(PathAddress.EMPTY_ADDRESS).getModel(); ModelNode newValue = model.has(attributeName) ? model.get(attributeName) : new ModelNode(); emitAttributeValueWrittenNotification(context, address, attributeName, oldValue, newValue); } else { assert attributeAccess.getStorageType() == AttributeAccess.Storage.RUNTIME; // if the attribute is a runtime attribute, its old and new values must // be read using the attribute's read handler and the write operation // must be sandwiched between the 2 calls to the read handler. // Each call to the read handlers will have their own results while // the call to the write handler will use this OSH context result. OperationContext.Stage currentStage = context.getCurrentStage(); final ModelNode readAttributeOperation = Util.createOperation(READ_ATTRIBUTE_OPERATION, address); readAttributeOperation.get(NAME.getName()).set(attributeName); ReadAttributeHandler readAttributeHandler = new ReadAttributeHandler(null, null, false); // create 2 model nodes to store the result of the read-attribute operations // before and after writing the value final ModelNode oldValue = new ModelNode(); final ModelNode newValue = new ModelNode(); // We're going to add a bunch of steps, but we want them to execute right away // so we use the 'addFirst=true' param to addStep. That means we add them // in reverse order of how they will execute // 4th OSH is to emit the notification context.addStep( new OperationStepHandler() { @Override public void execute(OperationContext context, ModelNode operation) throws OperationFailedException { // aggregate data from the 2 read-attribute operations emitAttributeValueWrittenNotification( context, address, attributeName, oldValue.get(RESULT), newValue.get(RESULT)); } }, currentStage, true); // 3rd OSH is to read the new value context.addStep(newValue, readAttributeOperation, readAttributeHandler, currentStage, true); // 2nd OSH is to write the value context.addStep( new OperationStepHandler() { @Override public void execute(OperationContext context, ModelNode operation) throws OperationFailedException { doExecuteInternal( context, operation, attributeAccess, attributeName, oldValue.get(RESULT), useEnhancedSyntax, attributeExpression); } }, currentStage, true); // 1st OSH is to read the old value context.addStep(oldValue, readAttributeOperation, readAttributeHandler, currentStage, true); } } }