docs: void verifyProcess(VerifyServer verifyServer, LaunchArguments createOptions) throws LaunchException {
          if (verifyServer == null || verifyServer == VerifyServer.SKIP) {
              return;
          }
  
          boolean generatePassword = createOptions == null || createOptions.getOption("no-password") == null;
          if (!configDir.exists()) {
              if (verifyServer == VerifyServer.CREATE ||
                  (verifyServer == VerifyServer.CREATE_DEFAULT && getDefaultProcessName().equals(processName))) {
  
                  // start creating server and copy boot/config files as needed
                  // first make sure we can find the source files we need...
                  //
                  // CREATE_DEFAULT will only appear here if someone launches
                  // without the server script or uses a non-default
                  // WLP_OUTPUT_DIR (otherwise, the server script will have
                  // already created the directory).  In any case, we should only
                  // respect --template for --create.
                  File template = findProcessTemplate(verifyServer == VerifyServer.CREATE ? createOptions : null);
  
                  // Assuming we can find the files we need to create the server, let's create the server directory
                  if (configDir.mkdirs()) {
                      try {
                          createConfigDirectory(template);
                          generateServerEnv(generatePassword);
                      } catch (IOException e) {
                          throw new LocationException("Error occurred while trying to create new process "
                                                      + processName, MessageFormat.format(BootstrapConstants.messages.getString(getErrorCreatingNewProcessMessageKey()), processName,
                                                                                          configDir.getAbsolutePath(),
                                                                                          e.getMessage()), e);
                      }
                  } else {
                      //if the location hasn't been created since our last exist check
                      if (!!!configDir.exists()) {
                          throw new LocationException("Unable to create process config directory " + configDir.getAbsolutePath(), MessageFormat.format(
                                                                                                                                                       BootstrapConstants.messages.getString(getErrorCreatingNewProcessMkDirFailMessageKey()),
                                                                                                                                                       processName,
                                                                                                                                                       configDir.getAbsolutePath()), null);
                      } else {
                          //something else created the server location AFTER we did the exists check at the start of this method
                          throw new LocationException("Something else has been detected creating the process config directory "
                                                      + configDir.getAbsolutePath(), MessageFormat.format(BootstrapConstants.messages.getString(getErrorCreatingNewProcessExistsMessageKey()),
                                                                                                          processName,
                                                                                                          configDir.getAbsolutePath()), null);
  
                      }
                  }
              } else {
                  // Throw exception for missing server config.
                  LaunchException le = new LaunchException("Process config directory does not exist, and --create option not specified for "
                                                           + processName, MessageFormat.format(BootstrapConstants.messages.getString(getErrorNoExistingProcessMessageKey()),
                                                                                               processName,
                                                                                               configDir.getAbsolutePath()));
                  le.setReturnCode(ReturnCode.SERVER_NOT_EXIST_STATUS);
                  throw le;
              }
          } else {
              if (verifyServer == BootstrapConstants.VerifyServer.CREATE) {
                  LaunchException le = new LaunchException("Unable to create the process " + processName
                                                           + " because the process config directory already exists", MessageFormat.format(BootstrapConstants.messages.getString(getErrorProcessDirExistsMessageKey()),
                                                                                                                                          processName, configDir));
                  le.setReturnCode(ReturnCode.REDUNDANT_ACTION_STATUS);
                  throw le;
              }
  
              // make sure we have a server.xml file
              File f = getConfigFile(getProcessXMLFilename());
  
              // The server directory already exists, but server.xml might not
              // exist for defaultServer.  This happens when the server script
              // creates an empty output directory (which is the same as the
              // config directory by default) so it can use the output directory
              // as the current working directory.
              if (!f.exists() && (verifyServer == VerifyServer.CREATE_DEFAULT && getDefaultProcessName().equals(processName))) {
                  try {
                      createConfigDirectory(findProcessTemplate(null));
                      generateServerEnv(generatePassword);
                  } catch (IOException e) {
                      // We can ignore this because a message will be output in a moment.
                  }
              }
  
              if (!f.exists() || !f.canRead()) {
                  throw new LocationException("Not Found " + f.getAbsolutePath(), MessageFormat.format(BootstrapConstants.messages.getString("error.badConfigRoot"),
                                                                                                       f.getAbsolutePath(), "file not found"));
              }
          }
      }