docs: public void execute(final OperationContext context, final ModelNode operation) throws OperationFailedException {
          final Resource resource = context.createResource(PathAddress.EMPTY_ADDRESS);
  
          final ModelNode model = resource.getModel();
          for (SimpleAttributeDefinition atr : ALL_ATTRIBUTES) {
              atr.validateAndSet(operation, model);
          }
  
          recordCapabilitiesAndRequirements(context, resource, ALL_ATTRIBUTES);
  
          boolean stepCompleted = false;
  
          if (context.isNormalServer()) {
  
              final boolean enabled = SCAN_ENABLED.resolveModelAttribute(context, operation).asBoolean();
              final boolean bootTimeScan = context.isBooting() && enabled;
  
  
              final String path = DeploymentScannerDefinition.PATH.resolveModelAttribute(context, operation).asString();
              final ModelNode relativeToNode = RELATIVE_TO.resolveModelAttribute(context, operation);
              final String relativeTo = relativeToNode.isDefined() ?  relativeToNode.asString() : null;
              final boolean autoDeployZip = AUTO_DEPLOY_ZIPPED.resolveModelAttribute(context, operation).asBoolean();
              final boolean autoDeployExp = AUTO_DEPLOY_EXPLODED.resolveModelAttribute(context, operation).asBoolean();
              final boolean autoDeployXml = AUTO_DEPLOY_XML.resolveModelAttribute(context, operation).asBoolean();
              final long deploymentTimeout = DEPLOYMENT_TIMEOUT.resolveModelAttribute(context, operation).asLong();
              final int scanInterval = SCAN_INTERVAL.resolveModelAttribute(context, operation).asInt();
              final boolean rollback = RUNTIME_FAILURE_CAUSES_ROLLBACK.resolveModelAttribute(context, operation).asBoolean();
  
              final ScheduledExecutorService scheduledExecutorService = createScannerExecutorService();
  
              final FileSystemDeploymentService bootTimeScanner;
              if (bootTimeScan) {
                  final String pathName = pathManager.resolveRelativePathEntry(path, relativeTo);
                  File relativePath = null;
                  if (relativeTo != null) {
                      relativePath = new File(pathManager.getPathEntry(relativeTo).resolvePath());
                  }
                  PathAddress ownerAddress = context.getCurrentAddress();
                  bootTimeScanner = new FileSystemDeploymentService(ownerAddress, relativeTo, new File(pathName), relativePath, null, scheduledExecutorService,
                          (ControlledProcessStateService) context.getServiceRegistry(false).getService(ControlledProcessStateService.SERVICE_NAME).getValue());
                  bootTimeScanner.setAutoDeployExplodedContent(autoDeployExp);
                  bootTimeScanner.setAutoDeployZippedContent(autoDeployZip);
                  bootTimeScanner.setAutoDeployXMLContent(autoDeployXml);
                  bootTimeScanner.setDeploymentTimeout(deploymentTimeout);
                  bootTimeScanner.setScanInterval(scanInterval);
                  bootTimeScanner.setRuntimeFailureCausesRollback(rollback);
              } else {
                  bootTimeScanner = null;
              }
  
              context.addStep(new OperationStepHandler() {
                  public void execute(final OperationContext context, final ModelNode operation) throws OperationFailedException {
                      performRuntime(context, operation, model, scheduledExecutorService, bootTimeScanner);
  
                      // We count on the context's automatic service removal on rollback
                      context.completeStep(OperationContext.ResultHandler.NOOP_RESULT_HANDLER);
                  }
              }, OperationContext.Stage.RUNTIME);
  
  
              if (bootTimeScan) {
                  final AtomicReference<ModelNode> deploymentOperation = new AtomicReference<ModelNode>();
                  final AtomicReference<ModelNode> deploymentResults = new AtomicReference<ModelNode>(new ModelNode());
                  final CountDownLatch scanDoneLatch = new CountDownLatch(1);
                  final CountDownLatch deploymentDoneLatch = new CountDownLatch(1);
                  final DeploymentOperations deploymentOps = new BootTimeScannerDeployment(deploymentOperation, deploymentDoneLatch, deploymentResults, scanDoneLatch);
  
                  scheduledExecutorService.submit(new Runnable() {
                      @Override
                      public void run() {
                          try {
                              bootTimeScanner.bootTimeScan(deploymentOps);
                          } catch (Throwable t){
                              DeploymentScannerLogger.ROOT_LOGGER.initialScanFailed(t);
                          } finally {
                              scanDoneLatch.countDown();
                          }
                      }
                  });
                  boolean interrupted = false;
                  boolean asyncCountDown = false;
                  try {
                      scanDoneLatch.await();
  
                      final ModelNode op = deploymentOperation.get();
                      if (op != null) {
                          final ModelNode result = new ModelNode();
                          final PathAddress opPath = PathAddress.pathAddress(op.get(OP_ADDR));
                          final OperationStepHandler handler = context.getRootResourceRegistration().getOperationHandler(opPath, op.get(OP).asString());
                          context.addStep(result, op, handler, OperationContext.Stage.MODEL);
  
                          stepCompleted = true;
                          context.completeStep(new OperationContext.ResultHandler() {
                              @Override
                              public void handleResult(OperationContext.ResultAction resultAction, OperationContext context, ModelNode operation) {
                                  try {
                                      deploymentResults.set(result);
                                  } finally {
                                      deploymentDoneLatch.countDown();
                                  }
                              }
                          });
                          asyncCountDown = true;
  
                      } else {
                          stepCompleted = true;
                          context.completeStep(OperationContext.RollbackHandler.NOOP_ROLLBACK_HANDLER);
                      }
                  } catch (InterruptedException e) {
                      interrupted = true;
                      throw new RuntimeException(e);
                  } finally {
                      if (!asyncCountDown) {
                          deploymentDoneLatch.countDown();
                      }
                      if (interrupted) {
                          Thread.currentThread().interrupt();
                      }
                  }
              }
          }
  
          if (!stepCompleted) {
              context.completeStep(OperationContext.RollbackHandler.NOOP_ROLLBACK_HANDLER);
          }
      }