fix server-result transformation

controller/src/main/java/org/jboss/as/controller/registry/OperationTransformerRegistry.java

@@ -115,7 +115,7 @@ protected OperationTransformerRegistry resolveChild(final Iterator<PathElement>
             if(sub == null) {
                 return null;
             }
-            return sub.get(element.getValue());
+            return sub.get(element.getValue(), iterator);
         }
     }
 
@@ -253,6 +253,17 @@ OperationTransformerRegistry get(final String value) {
             return entry;
         }
 
+        OperationTransformerRegistry get(final String value, Iterator<PathElement> iterator) {
+            OperationTransformerRegistry entry = childrenUpdater.get(this, value);
+            if(entry == null) {
+                entry = childrenUpdater.get(this, "*");
+                if(entry == null) {
+                    return null;
+                }
+            }
+            return entry.resolveChild(iterator);
+        }
+
         OperationTransformerRegistry create(final String value, final ResourceTransformerEntry resourceTransformer,final OperationTransformerEntry defaultTransformer) {
             for(;;) {
                 final Map<String, OperationTransformerRegistry> entries = childrenUpdater.get(this);

controller/src/main/java/org/jboss/as/controller/transform/CompositeOperationTransformer.java

@@ -59,7 +59,7 @@ TransformedOperation transformOperation(final TransformationContext context, fin
                 result = transformOperation(context, PathAddress.EMPTY_ADDRESS, step, false);
             } else {
                 final OperationTransformer transformer = target.resolveTransformer(stepAddress, operationName);
-                result = transformer.transformOperation(context, address, step);
+                result = transformer.transformOperation(context, stepAddress, step);
             }
             composite.get(STEPS).add(result.getTransformedOperation());
             steps.add(new Step(i, result));
@@ -82,8 +82,13 @@ public ModelNode transformResult(final ModelNode original) {
             for(final Step step : steps) {
                 final String id = "step-" + step.getStepCount();
                 final ModelNode stepResult = original.get(RESULT, id);
-                final OperationResultTransformer transformer = step.getResult();
-                result.get(id).set(transformer.transformResult(stepResult));
+                // Skip ignored steps
+                if(IGNORED.equals(stepResult.get(OUTCOME).asString())) {
+                    result.get(id).set(stepResult);
+                } else {
+                    final OperationResultTransformer transformer = step.getResult();
+                    result.get(id).set(transformer.transformResult(stepResult));
+                }
             }
             return response;
         }

controller/src/main/java/org/jboss/as/controller/transform/TransformerRegistry.java

@@ -129,6 +129,7 @@ public OperationTransformerRegistry resolveHost(final ModelVersion mgmtVersion,
         // The domain / host / servers
         final OperationTransformerRegistry root = domain.create(mgmtVersion, Collections.<PathAddress, ModelVersion>emptyMap());
         subsystem.mergeSubtree(root, PathAddress.pathAddress(PROFILE), subsystems);
+        subsystem.mergeSubtree(root, PathAddress.pathAddress(HOST, SERVER), subsystems);
         return root;
     }
 
@@ -165,8 +166,12 @@ public OperationTransformerRegistry resolveServer(final ModelVersion mgmtVersion
      */
     void addSubsystem(final OperationTransformerRegistry registry, final String name, final ModelVersion version) {
         final OperationTransformerRegistry profile = registry.getChild(PathAddress.pathAddress(PROFILE));
+        final OperationTransformerRegistry server = registry.getChild(PathAddress.pathAddress(HOST, SERVER));
         final PathAddress address = PathAddress.pathAddress(PathElement.pathElement(ModelDescriptionConstants.SUBSYSTEM, name));
         subsystem.mergeSubtree(profile, Collections.singletonMap(address, version));
+        if(server != null) {
+            subsystem.mergeSubtree(server, Collections.singletonMap(address, version));
+        }
     }
 
     public static Map<PathAddress, ModelVersion> resolveVersions(ExtensionRegistry extensionRegistry) {

controller/src/test/java/org/jboss/as/controller/test/OperationTransformationTestCase.java

@@ -79,6 +79,7 @@ public class OperationTransformationTestCase {
         subsystems.add("resource-adapters", "1.1");
     }
 
+    private final Resource resourceRoot = Resource.Factory.create();
     private final GlobalTransformerRegistry registry = new GlobalTransformerRegistry();
     private final ManagementResourceRegistration resourceRegistration = ManagementResourceRegistration.Factory.create(ROOT);
     private final OperationTransformer NOOP_TRANSFORMER = new OperationTransformer() {
@@ -87,22 +88,19 @@ public TransformedOperation transformOperation(TransformationContext context, Pa
             return new TransformedOperation(new ModelNode(), OperationResultTransformer.ORIGINAL_RESULT);
         }
     };
-    private final Resource resourceRoot = Resource.Factory.create();
+    private final OperationTransformer OPERATION_TRANSFORMER = new OperationTransformer() {
+        @Override
+        public TransformedOperation transformOperation(TransformationContext context, PathAddress address, ModelNode operation) throws OperationFailedException {
+            final ModelNode transformed = operation.clone();
+            transformed.get("param1").set("value1");
+            return new TransformedOperation(transformed, OperationResultTransformer.ORIGINAL_RESULT);
+        }
+    };
 
     @Before
     public void setUp() {
         registry.discardOperation(TEST_DISCARD, 1, 1, "discard");
-        final OperationTransformer transformer = new AbstractOperationTransformer() {
-
-            @Override
-            protected ModelNode transform(TransformationContext context, PathAddress address, ModelNode operation) {
-                final ModelNode transformed = operation.clone();
-                transformed.get("param1").set("value1");
-                return transformed;
-            }
-
-        };
-        registry.registerTransformer(TEST_NORMAL, 1, 2, "normal", transformer);
+        registry.registerTransformer(TEST_NORMAL, 1, 2, "normal", OPERATION_TRANSFORMER);
     }
 
     @Test
@@ -214,16 +212,30 @@ public void testAddSubsystem() throws Exception {
 
         final ModelVersion subsystem = ModelVersion.create(1, 2);
         final TransformerRegistry registry = TransformerRegistry.Factory.create(null);
-        registry.registerSubsystemTransformers("test", subsystem, ResourceTransformer.DISCARD);
+        TransformersSubRegistration sub = registry.registerSubsystemTransformers("test", subsystem, ResourceTransformer.DISCARD);
+        sub.registerOperationTransformer("test", OPERATION_TRANSFORMER);
 
-        final TransformationTarget target = create(registry, ModelVersion.create(1, 2, 3));
-        target.addSubsystemVersion("test", subsystem);
+        final TransformationTarget host = create(registry, ModelVersion.create(1, 2, 3));
+        host.addSubsystemVersion("test", subsystem);
 
+        final PathAddress profile = PathAddress.pathAddress(PathElement.pathElement(ModelDescriptionConstants.PROFILE, "test"));
+        final PathAddress serverAddress = PathAddress.pathAddress(PathElement.pathElement(ModelDescriptionConstants.HOST, "test"), PathElement.pathElement(ModelDescriptionConstants.RUNNING_SERVER, "test"));
+        final PathAddress subsytemAddress = PathAddress.pathAddress(PathElement.pathElement(ModelDescriptionConstants.SUBSYSTEM, "test"));
+
+        final OperationTransformer profileTransformer = host.resolveTransformer(profile.append(subsytemAddress), "test");
+        Assert.assertEquals(profileTransformer, OPERATION_TRANSFORMER);
+
+        final OperationTransformer serverTransformer = host.resolveTransformer(serverAddress.append(subsytemAddress), "test");
+        Assert.assertEquals(serverTransformer, OPERATION_TRANSFORMER);
 
     }
 
     protected TransformationTarget create(final TransformerRegistry registry, ModelVersion version) {
-        return TransformationTargetImpl.create(registry, version, Collections.<PathAddress, ModelVersion>emptyMap(), null, TransformationTarget.TransformationTargetType.HOST);
+        return create(registry, version, TransformationTarget.TransformationTargetType.HOST);
+    }
+
+    protected TransformationTarget create(final TransformerRegistry registry, ModelVersion version, TransformationTarget.TransformationTargetType type) {
+        return TransformationTargetImpl.create(registry, version, Collections.<PathAddress, ModelVersion>emptyMap(), null, type);
     }
 
     protected Resource transform(final TransformationTarget target, final Resource root) throws OperationFailedException {

host-controller/src/main/java/org/jboss/as/domain/controller/operations/coordination/DomainOperationContext.java

@@ -22,6 +22,9 @@
 
 package org.jboss.as.domain.controller.operations.coordination;
 
+import org.jboss.as.controller.OperationContext;
+import org.jboss.as.controller.OperationFailedException;
+import org.jboss.as.controller.TransformingProxyController;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.FAILURE_DESCRIPTION;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.RESULT;
@@ -33,6 +36,8 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
+import org.jboss.as.controller.transform.OperationResultTransformer;
+import org.jboss.as.controller.transform.OperationTransformer;
 import org.jboss.as.domain.controller.LocalHostControllerInfo;
 import org.jboss.as.domain.controller.ServerIdentity;
 import org.jboss.dmr.ModelNode;
@@ -49,6 +54,7 @@ public class DomainOperationContext {
     private final ModelNode coordinatorResult = new ModelNode();
     private final ConcurrentMap<String, ModelNode> hostControllerResults = new ConcurrentHashMap<String, ModelNode>();
     private final ConcurrentMap<ServerIdentity, ModelNode> serverResults = new ConcurrentHashMap<ServerIdentity, ModelNode>();
+    private final ConcurrentMap<String, HostControllerUpdateTask.ExecutedHostRequest> finalResultFutures = new ConcurrentHashMap<String, HostControllerUpdateTask.ExecutedHostRequest>();
 
     private final Map<String, Boolean> serverGroupStatuses = new ConcurrentHashMap<String, Boolean>();
     private volatile boolean completeRollback = true;
@@ -142,6 +148,29 @@ public ModelNode getServerResult(String hostName, String serverName, String... s
         return result;
     }
 
+    /*
+     * Transform an operation for a server. This will also delegate to the host-controller result-transformer.
+     */
+    public OperationTransformer.TransformedOperation transformServerOperation(final String hostName, final TransformingProxyController remoteProxyController, final OperationContext context, final ModelNode original) throws OperationFailedException {
+        final OperationTransformer.TransformedOperation transformed = remoteProxyController.transformOperation(context, original);
+        final HostControllerUpdateTask.ExecutedHostRequest hostRequest = finalResultFutures.get(hostName);
+        if(hostRequest == null) {
+            // in case it's local hosts-controller
+            return transformed;
+        }
+        return new OperationTransformer.TransformedOperation(transformed.getTransformedOperation(), new OperationResultTransformer() {
+            @Override
+            public ModelNode transformResult(ModelNode result) {
+                final ModelNode step1 = transformed.transformResult(result);
+                return hostRequest.transformResult(step1);
+            }
+        });
+    }
+
+    protected void recordHostRequest(final String hostName, final HostControllerUpdateTask.ExecutedHostRequest request) {
+        finalResultFutures.put(hostName, request);
+    }
+
     private String[] getTranslatedSteps(String serverName, ModelNode hostResults, String[] stepLabels) {
         String[] result = null;
         ModelNode domainMappedOp = getDomainMappedOperation(serverName, hostResults);

host-controller/src/main/java/org/jboss/as/domain/controller/operations/coordination/DomainRolloutStepHandler.java

@@ -235,9 +235,10 @@ private void pushToServers(final OperationContext context, final Map<ServerIdent
 
                 @Override
                 protected boolean execute(TransactionalProtocolClient.TransactionalOperationListener<ServerTaskExecutor.ServerOperation> listener, ServerIdentity server, ModelNode original) throws OperationFailedException {
-                    ProxyController proxy = hostProxies.get(server.getHostName());
+                    final String hostName = server.getHostName();
+                    ProxyController proxy = hostProxies.get(hostName);
                     if (proxy == null) {
-                        if (localHostName.equals(server.getHostName())) {
+                        if (localHostName.equals(hostName)) {
                             // Use our server proxies
                             proxy = serverProxies.get(server.getServerName());
                         }
@@ -250,7 +251,7 @@ protected boolean execute(TransactionalProtocolClient.TransactionalOperationList
                     }
                     // Transform the server-results
                     final TransformingProxyController remoteProxyController = (TransformingProxyController) proxy;
-                    final OperationTransformer.TransformedOperation transformed = remoteProxyController.transformOperation(context, original);
+                    final OperationTransformer.TransformedOperation transformed = domainOperationContext.transformServerOperation(hostName, remoteProxyController, context, original);
                     final ModelNode transformedOperation = transformed.getTransformedOperation();
                     final OperationResultTransformer resultTransformer = transformed.getResultTransformer();
                     final TransactionalProtocolClient client = remoteProxyController.getProtocolClient();

host-controller/src/main/java/org/jboss/as/domain/controller/operations/coordination/DomainSlaveHandler.java

@@ -92,6 +92,7 @@ public void execute(final OperationContext context, final ModelNode operation) t
             final HostControllerUpdateTask task = new HostControllerUpdateTask(host, op.clone(), context, proxyController);
             // Execute the operation on the remote host
             final HostControllerUpdateTask.ExecutedHostRequest finalResult = task.execute(listener);
+            domainOperationContext.recordHostRequest(host, finalResult);
             finalResults.put(host, finalResult);
         }
 
@@ -181,8 +182,10 @@ public void execute(final OperationContext context, final ModelNode operation) t
                 for(final TransactionalProtocolClient.PreparedOperation<HostControllerUpdateTask.ProxyOperation> prepared : results) {
                     final String hostName = prepared.getOperation().getName();
                     try {
+                        final HostControllerUpdateTask.ExecutedHostRequest request = finalResults.get(hostName);
                         final ModelNode finalResult = prepared.getFinalResult().get();
-                        domainOperationContext.addHostControllerResult(hostName, finalResult);
+                        final ModelNode transformedResult = request.transformResult(finalResult);
+                        domainOperationContext.addHostControllerResult(hostName, transformedResult);
 
                         if (HOST_CONTROLLER_LOGGER.isTraceEnabled()) {
                             HOST_CONTROLLER_LOGGER.tracef("Final result for remote host %s is %s", hostName, finalResult);

host-controller/src/main/java/org/jboss/as/domain/controller/operations/coordination/HostControllerExecutionSupport.java

@@ -290,7 +290,6 @@ public Map<ServerIdentity, ModelNode> getServerOps(ServerOperationProvider provi
                         serverNode.get(stepLabel).set(entry.getValue());
                     }
                 }
-
                 return result;
             }
 

host-controller/src/main/java/org/jboss/as/domain/controller/operations/coordination/HostControllerUpdateTask.java

@@ -26,8 +26,10 @@
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.COMPOSITE;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.DOMAIN_RESULTS;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.EXTENSION;
+import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.FAILURE_DESCRIPTION;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.IGNORED;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP;
+import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OPERATION_HEADERS;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP_ADDR;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OUTCOME;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.RESULT;
@@ -93,10 +95,20 @@ public ExecutedHostRequest execute(final ProxyOperationListener listener) {
         final OperationAttachments operationAttachments = new DelegatingOperationAttachments(context);
         final SubsystemInfoOperationListener subsystemListener = new SubsystemInfoOperationListener(listener, proxyController.getTransformers());
         try {
+
             final OperationTransformer.TransformedOperation transformationResult = proxyController.transformOperation(context, operation);
             final ModelNode transformedOperation = transformationResult.getTransformedOperation();
             final ProxyOperation proxyOperation = new ProxyOperation(name, transformedOperation, messageHandler, operationAttachments);
             try {
+                // Make sure we preserve the operation headers like PrepareStepHandler.EXECUTE_FOR_COORDINATOR
+                if(transformedOperation != null) {
+                    transformedOperation.get(OPERATION_HEADERS).set(operation.get(OPERATION_HEADERS));
+                    // If the operation was transformed in any way
+                    if(operation != transformedOperation) {
+                        // push all operations (incl. read-only) to the servers
+                        transformedOperation.get(OPERATION_HEADERS, ServerOperationsResolverHandler.DOMAIN_PUSH_TO_SERVERS).set(true);
+                    }
+                }
                 final AsyncFuture<ModelNode> result = client.execute(subsystemListener, proxyOperation);
                 return new ExecutedHostRequest(result, transformationResult);
             } catch (IOException e) {
@@ -174,7 +186,25 @@ public String getFailureDescription() {
 
         @Override
         public ModelNode transformResult(ModelNode result) {
-            return resultTransformer.transformResult(result);
+
+            if(result.get(RESULT).has(DOMAIN_RESULTS)) {
+                final ModelNode domainResults = result.get(RESULT, DOMAIN_RESULTS);
+                if(domainResults.getType() == ModelType.STRING && IGNORED.equals(domainResults.asString())) {
+                    // Untransformed
+                    return result;
+                }
+                final ModelNode userResult = new ModelNode();
+                userResult.get(OUTCOME).set(result.get(OUTCOME));
+                userResult.get(RESULT).set(domainResults);
+                if(result.hasDefined(FAILURE_DESCRIPTION)) {
+                    userResult.get(FAILURE_DESCRIPTION).set(result.get(FAILURE_DESCRIPTION));
+                }                // Transform the result
+                final ModelNode transformed = resultTransformer.transformResult(userResult);
+                result.get(RESULT, DOMAIN_RESULTS).set(transformed.get(RESULT));
+                return result;
+            } else {
+                return resultTransformer.transformResult(result);
+            }
         }
 
         public void asyncCancel() {

host-controller/src/main/java/org/jboss/as/domain/controller/operations/coordination/OperationCoordinatorStepHandler.java

@@ -150,12 +150,6 @@ private void executeDirect(OperationContext context, ModelNode operation) throws
         final String operationName =  operation.require(OP).asString();
 
         OperationStepHandler stepHandler = null;
-
-        final PathAddress address = PathAddress.pathAddress(operation.require(OP_ADDR));
-        if(localSlaveHandler.isResourceExcluded(address)) {
-            System.out.println("should be ignoring this stuff! " + operation);
-        }
-
         final ImmutableManagementResourceRegistration registration = context.getResourceRegistration();
         if (registration != null) {
             stepHandler = registration.getOperationHandler(PathAddress.EMPTY_ADDRESS, operationName);