docs: protected OperationResponse internalExecute(final ModelNode operation, final OperationMessageHandler handler, final OperationTransactionControl control,
                                                  final OperationAttachments attachments, final OperationStepHandler prepareStep, final boolean attemptLock, boolean partialModel) {
  
          SecurityManager sm = System.getSecurityManager();
          if (sm != null) {
              sm.checkPermission(ModelController.ACCESS_PERMISSION);
          }
  
          final ModelNode responseNode = validateOperation(operation);
          if(responseNode.hasDefined(FAILURE_DESCRIPTION)) {
              return OperationResponse.Factory.createSimple(responseNode);
          }
  
          OperationHeaders headers;
          try {
              headers = OperationHeaders.fromOperation(operation);
          } catch (OperationFailedException ofe) {
              return OperationHeaders.fromFailure(ofe);
          }
  
          // Report the correct operation response, otherwise the preparedResult would only contain
          // the result of the last active step in a composite operation
          final OperationTransactionControl originalResultTxControl = control == null ? null : new OperationTransactionControl() {
              @Override
              public void operationPrepared(OperationTransaction transaction, ModelNode result, OperationContext context) {
                  control.operationPrepared(transaction, responseNode, context);
              }
  
              @Override
              public void operationPrepared(OperationTransaction transaction, ModelNode result) {
                  control.operationPrepared(transaction, responseNode);
              }
          };
          Map<String, OperationResponse.StreamEntry> responseStreams;
          AccessMechanism accessMechanism = null;
          AccessAuditContext accessContext = SecurityActions.currentAccessAuditContext();
          if (accessContext != null) {
              // External caller of some sort.
  
              // Internal domain ManagementRequestHandler impls will set a header to track an op through the domain
              // This header will only be set at this point if the request came in that way; for user-originated
              // requests on this process the header is added later during op execution by OperationCoordinatorStepHandler
              if (headers.getDomainUUID() != null) {
                  accessContext.setDomainUuid(headers.getDomainUUID());
                  accessContext.setDomainRollout(true);
              }
              // Native and http ManagementRequestHandler impls, plus those used for intra-domain comms
              // will always set a header to specify the access mechanism. JMX directly sets it on the accessContext
              if (headers.getAccessMechanism() != null) {
                  accessContext.setAccessMechanism(headers.getAccessMechanism());
              }
              accessMechanism = accessContext.getAccessMechanism();
          } // else its an internal caller as external callers always get an AccessAuditContext
  
          // WFCORE-184. Exclude external callers during boot. AccessMechanism is always set for external callers
          if (accessMechanism != null && bootingFlag.get()) {
              return handleExternalRequestDuringBoot();
          }
  
          for (;;) {
              responseStreams = null;
              // Create a random operation-id
              final Integer operationID = random.nextInt();
              final OperationContextImpl context = new OperationContextImpl(operationID, operation.get(OP).asString(),
                      operation.get(OP_ADDR), this, processType, runningModeControl.getRunningMode(),
                      headers, handler, attachments, managementModel.get(), originalResultTxControl, processState, auditLogger,
                      bootingFlag.get(), hostServerGroupTracker, accessContext, notificationSupport,
                      false, extraValidationStepHandler, partialModel, securityIdentitySupplier);
              // Try again if the operation-id is already taken
              if(activeOperations.putIfAbsent(operationID, context) == null) {
                  //noinspection deprecation
                  CurrentOperationIdHolder.setCurrentOperationID(operationID);
                  boolean shouldUnlock = false;
                  try {
                      if (attemptLock) {
                          if (!controllerLock.detectDeadlockAndGetLock(operationID)) {
                              responseNode.get(OUTCOME).set(FAILED);
                              responseNode.get(FAILURE_DESCRIPTION).set(ControllerLogger.ROOT_LOGGER.cannotGetControllerLock());
                              return OperationResponse.Factory.createSimple(responseNode);
                          }
                          shouldUnlock = true;
                      }
  
                      context.addStep(responseNode, operation, prepareStep, OperationContext.Stage.MODEL);
                      ControllerLogger.MGMT_OP_LOGGER.tracef("Executing %s", operation);
                      context.executeOperation();
                      responseStreams = context.getResponseStreams();
                  } catch (Error e) {
                      try {
                          controllerUnstable();
                      } catch (Error ignored) {
                          // we already have the main error
                      }
                      throw e;
                  } finally {
  
                      if (!responseNode.hasDefined(RESPONSE_HEADERS) || !responseNode.get(RESPONSE_HEADERS).hasDefined(PROCESS_STATE)) {
                          ControlledProcessState.State state = processState.getState();
                          switch (state) {
                              case RELOAD_REQUIRED:
                              case RESTART_REQUIRED:
                                  responseNode.get(RESPONSE_HEADERS, PROCESS_STATE).set(state.toString());
                                  break;
                              default:
                                  break;
                          }
                      }
  
                      if (shouldUnlock) {
                          controllerLock.unlock(operationID);
                      }
                      activeOperations.remove(operationID);
                      //noinspection deprecation
                      CurrentOperationIdHolder.setCurrentOperationID(null);
                  }
                  break;
              }
          }
          if (responseStreams == null || responseStreams.size() == 0) {
              return OperationResponse.Factory.createSimple(responseNode);
          } else {
              return new OperationResponseImpl(responseNode, responseStreams);
          }
      }