docs: private void populateServerGroupResults(final OperationContext context, final Map<ServerIdentity, ModelNode> serverResults) {
  
          final Set<String> groupNames = new TreeSet<String>();
          final Map<String, Set<HostServer>> groupToServerMap = new HashMap<String, Set<HostServer>>();
          for (Map.Entry<ServerIdentity, ModelNode> entry : serverResults.entrySet()) {
              final String serverGroup = entry.getKey().getServerGroupName();
              groupNames.add(serverGroup);
              final String hostName = entry.getKey().getHostName();
              final String serverName = entry.getKey().getServerName();
              if (!groupToServerMap.containsKey(serverGroup)) {
                  groupToServerMap.put(serverGroup, new TreeSet<HostServer>());
              }
              groupToServerMap.get(serverGroup).add(new HostServer(hostName, serverName, entry.getValue()));
          }
  
          boolean serverGroupSuccess = false;
          ModelNode failureReport = new ModelNode();
          for (String groupName : groupNames) {
              final ModelNode groupNode = new ModelNode();
              boolean groupFailure = multiphaseContext.isServerGroupRollback(groupName);
              if (groupFailure) {
                  // TODO revisit if we should report this for the whole group, since the result might not be accurate
                  // groupNode.get(ROLLED_BACK).set(true);
              } else {
                  serverGroupSuccess = true;
              }
              for (HostServer hostServer : groupToServerMap.get(groupName)) {
                  final ModelNode hostResult = hostServer.result.clone();
                  if(hostResult.hasDefined(RESPONSE_HEADERS)){
                      final ModelNode responseHeaders = hostResult.get(RESPONSE_HEADERS);
                      if(responseHeaders.hasDefined(WARNINGS)){
                          responseHeaders.remove(WARNINGS);
                      }
                      if(responseHeaders.keys().size() == 0){
                          hostResult.remove(RESPONSE_HEADERS);
                      }
                  }
                  groupNode.get(HOST, hostServer.hostName, hostServer.serverName, RESPONSE).set(hostResult);
                  if (groupFailure && hostResult.hasDefined(OUTCOME)
                          && FAILED.equals(hostResult.get(OUTCOME).asString())
                          && hostResult.hasDefined(FAILURE_DESCRIPTION)) {
                      ModelNode failDesc = hostResult.get(FAILURE_DESCRIPTION);
                      if (!CompositeOperationHandler.getUnexplainedFailureMessage().equals(failDesc.asString())) {
                          failureReport.get(SERVER_GROUP, groupName, HOST, hostServer.hostName, hostServer.serverName).set(failDesc);
                      } // else the server just reported an unexplained composite failure.
                        // We assume it's due to domain-wide rollback, which is not useful information
                        // so don't include this server in the top level failure description
                  }
              }
              context.getServerResults().get(groupName).set(groupNode);
          }
          if (!serverGroupSuccess) {
              if (failureReport.isDefined()) {
                  ModelNode fullFailure = new ModelNode();
                  fullFailure.get(DomainControllerLogger.HOST_CONTROLLER_LOGGER.operationFailedOrRolledBackWithCause()).set(failureReport);
                  context.getFailureDescription().set(fullFailure);
              } else {
                  context.getFailureDescription().set(DomainControllerLogger.HOST_CONTROLLER_LOGGER.operationFailedOrRolledBack());
              }
          }
      }