code: @Override
      public void execute() throws MojoExecutionException {
          try {
              init();
          } catch (ContextException e) {
              throw new MojoExecutionException("Cannot extract the watchers from the context", e);
          }
  
          if (wisdomDirectory != null) {
              getLog().info("Wisdom Directory set to " + wisdomDirectory.getAbsolutePath() + " - " +
                      "skipping the execution of the wisdom server for " + project.getArtifactId());
  
              // Here things are a bit tricky. As we are not going to start the Wisdom server,
              // the current thread is going to continue. We need to hold it and release it when
              // the JVM stops. For this purpose we register a shutdown hook that is going to
              // release the current thread we put in the waiting queue. This synchronization
              // protocol is quite safe, as only one thread can enter this block.
  
              // Register a shutdown hook that will unblock the execution when called.
              Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
  
                  /**
                   * Calls the unblock method.
                   */
                  @Override
                  public void run() {
                      unblock();
                  }
              }));
  
              /**
               * Entering a blocking block.
               * We are going to wait until the JVM shuts down.
               */
              synchronized (this) {
                  try {
                      // Here again, it's an unconditional wait. There are no condition on which we are waiting,
                      // we just hold the current thread until the JVM stops.
                      wait(); //NOSONAR
                  } catch (InterruptedException e) {
                      getLog().warn("We were interrupted", e);
                  }
              }
          } else {
              new WisdomExecutor().execute(this, shell || interactive, debug, jvmArgs, destroyer);
          }
          pipeline.shutdown();
  
      }
docs: Execute method, initializes the <em>watch</em> pipeline. If the {@link #wisdomDirectory}
  parameter is set then the execution of the wisdom server is skipped,
  and keeps the thread alive until the shutdown of the JVM. Otherwise the wisdom server is
  started. Before returning, the method cleans up the pipeline.
  
  @throws org.apache.maven.plugin.MojoExecutionException for init failures.