docs: @Override
      public void execute(OperationContext context, ModelNode operation) throws OperationFailedException {
          context.addStep(new OperationStepHandler() {
              @Override
              public void execute(final OperationContext context, final ModelNode operation) throws OperationFailedException {
                  final ReloadContext<T> reloadContext = initializeReloadContext(context, operation);
                  final ServiceController<?> service = context.getServiceRegistry(true).getRequiredService(rootService);
                  context.completeStep(new OperationContext.ResultHandler() {
                      @Override
                      public void handleResult(OperationContext.ResultAction resultAction, OperationContext context, ModelNode operation) {
                          final EarlyResponseSendListener sendListener = context.getAttachment(EarlyResponseSendListener.ATTACHMENT_KEY);
                          try {
                              if (resultAction == OperationContext.ResultAction.KEEP) {
                                  final UninterruptibleCountDownLatch latch = new UninterruptibleCountDownLatch(1);
                                  service.addListener(new LifecycleListener() {
                                      @Override
                                      public void handleEvent(final ServiceController<?> controller, final LifecycleEvent event) {
                                          latch.awaitUninterruptibly();
                                          if (event == LifecycleEvent.DOWN) {
                                              controller.removeListener(this);
                                              reloadContext.doReload(runningModeControl);
                                              controller.setMode(ServiceController.Mode.ACTIVE);
                                          }
                                      }
                                  });
                                  try {
                                      reloadContext.reloadInitiated(runningModeControl);
                                      processState.setStopping();
                                      try {
                                          // If we were interrupted during setStopping (i.e. while calling process state listeners)
                                          // we want to clear that so we don't disrupt the reload of MSC services.
                                          // Once we set STOPPING state we proceed. And we don't want this thread
                                          // to have interrupted status as that will just mess up checking for
                                          // container stability
                                          Thread.interrupted();
                                          // Now that we're in STOPPING state we can send the response to the caller
                                          if (sendListener != null) {
                                              sendListener.sendEarlyResponse(resultAction);
                                          }
                                      } finally {
                                          // If we set the process state to STOPPING, we must stop
                                          service.setMode(ServiceController.Mode.NEVER);
                                      }
                                  } finally {
                                      latch.countDown();
                                  }
                              }
                          } finally {
                              if (sendListener != null) {
                                  // even if we called this in the try block, it's ok to call it again.
                                  sendListener.sendEarlyResponse(resultAction);
                              }
                          }
                      }
                  });
              }
          }, OperationContext.Stage.RUNTIME);
      }