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();
          final String name = context.getCurrentAddressValue();
          pathAttribute.validateAndSet(operation, model);
          RELATIVE_TO_LOCAL.validateAndSet(operation, model);
  
          context.registerCapability(PATH_CAPABILITY.fromBaseCapability(context.getCurrentAddressValue()));
          RELATIVE_TO_LOCAL.addCapabilityRequirements(context, model.get(RELATIVE_TO.getName()));
  
          if (pathManager != null) {
              final String path = getPathValue(context, PATH_SPECIFIED, model);
              final String relativeTo = getPathValue(context, RELATIVE_TO, model);
              final PathEventContextImpl pathEventContext = pathManager.checkRestartRequired(context, name, Event.ADDED);
  
              if (pathEventContext.isInstallServices()) {
                  //Add entry to the path manager
                  pathManager.addPathEntry(name, path, relativeTo, false);
              }
  
              context.addStep(new OperationStepHandler() {
                  public void execute(final OperationContext context, final ModelNode operation) throws OperationFailedException {
                      final ServiceController<?> legacyService;
                      if (pathEventContext.isInstallServices()) {
  
                          //Add the legacy services
                          final ServiceTarget target = context.getServiceTarget();
                          if (relativeTo == null) {
                              legacyService = pathManager.addAbsolutePathService(target, name, path);
                          } else {
                              legacyService = pathManager.addRelativePathService(target, name, path, false, relativeTo);
                          }
                      } else {
                          legacyService = null;
                      }
  
                      context.completeStep(new OperationContext.RollbackHandler() {
                          public void handleRollback(OperationContext context, ModelNode operation) {
                              pathManager.removePathService(context, name);
                              if (pathEventContext.isInstallServices()) {
                                  if (legacyService != null) {
                                      context.removeService(legacyService.getName());
                                  }
                              } else {
                                  pathEventContext.revert();
                              }
                          }
                      });
                  }
              }, OperationContext.Stage.RUNTIME);
  
              context.completeStep(new OperationContext.RollbackHandler() {
                  public void handleRollback(OperationContext context, ModelNode operation) {
                      if (pathEventContext.isInstallServices()) {
                          try {
                              pathManager.removePathEntry(name, false);
                          } catch (OperationFailedException e) {
                              //Should not happen since 'false' passed in for the check parameter
                              throw new RuntimeException(e);
                          }
                      }
                  }
              });
          } else {
              context.completeStep(OperationContext.RollbackHandler.NOOP_ROLLBACK_HANDLER);
          }
  
      }