docs: private void processStages() {
  
          // Locate the next step to execute.
          ModelNode primaryResponse = null;
          Step step;
          do {
              step = steps.get(currentStage).pollFirst();
              if (step == null) {
  
                  if (currentStage == Stage.MODEL && addModelValidationSteps()) {
                      continue;
                  }
                  // No steps remain in this stage; give subclasses a chance to check status
                  // and approve moving to the next stage
                  if (!tryStageCompleted(currentStage)) {
                      // Can't continue
                      resultAction = ResultAction.ROLLBACK;
                      executeResultHandlerPhase(null);
                      return;
                  }
                  // Proceed to the next stage
                  if (currentStage.hasNext()) {
                      currentStage = currentStage.next();
                      if (currentStage == Stage.VERIFY) {
                          // a change was made to the runtime. Thus, we must wait
                          // for stability before resuming in to verify.
                          try {
                              awaitServiceContainerStability();
                          } catch (InterruptedException e) {
                              cancelled = true;
                              handleContainerStabilityFailure(primaryResponse, e);
                              executeResultHandlerPhase(null);
                              return;
                          }  catch (TimeoutException te) {
                              // The service container is in an unknown state; but we don't require restart
                              // because rollback may allow the container to stabilize. We force require-restart
                              // in the rollback handling if the container cannot stabilize (see OperationContextImpl.releaseStepLocks)
                              //processState.setRestartRequired();  // don't use our restartRequired() method as this is not reversible in rollback
                              handleContainerStabilityFailure(primaryResponse, te);
                              executeResultHandlerPhase(null);
                              return;
                          }
                      }
                  }
              } else {
                  // The response to the first step is what goes to the outside caller
                  if (primaryResponse == null) {
                      primaryResponse = step.response;
                  }
                  // Execute the step, but make sure we always finalize any steps
                  Throwable toThrow = null;
                  // Whether to return after try/finally
                  boolean exit = false;
                  try {
                      CapabilityRegistry.RuntimeStatus stepStatus = getStepExecutionStatus(step);
                      if (stepStatus == RuntimeCapabilityRegistry.RuntimeStatus.NORMAL) {
                          executeStep(step);
                      } else {
                          String header = stepStatus == RuntimeCapabilityRegistry.RuntimeStatus.RESTART_REQUIRED
                                  ? OPERATION_REQUIRES_RESTART : OPERATION_REQUIRES_RELOAD;
                          step.response.get(RESPONSE_HEADERS, header).set(true);
                      }
                  } catch (RuntimeException | Error re) {
                      resultAction = ResultAction.ROLLBACK;
                      toThrow = re;
                  } finally {
                      // See if executeStep put us in a state where we shouldn't do any more
                      if (toThrow != null || !canContinueProcessing()) {
                          // We're done.
                          executeResultHandlerPhase(toThrow);
                          exit = true; // we're on the return path
                      }
                  }
                  if (exit) {
                      return;
                  }
              }
          } while (currentStage != Stage.DONE);
  
          assert primaryResponse != null; // else ModelControllerImpl executed an op with no steps
  
          // All steps ran and canContinueProcessing returned true for the last one, so...
          executeDoneStage(primaryResponse);
      }