Add purge option to remove plugin CLI

By default, the remove plugin CLI command preserves configuration
files. This is so that if a user is upgrading the plugin (which is done
by first removing the old version and then installing the new version)
they do not lose their configuration file. Yet, there are circumstances
where preserving the configuration file is not desired. This commit adds
a purge option to the remove plugin CLI command.

Relates #24981

Author: jasontedor

core/src/main/java/org/elasticsearch/plugins/PluginsService.java

@@ -52,6 +52,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Locale;
@@ -60,6 +61,7 @@
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static org.elasticsearch.common.io.FileSystemUtils.isAccessibleDirectory;
 
@@ -288,6 +290,27 @@ static Set<Bundle> getModuleBundles(Path modulesDirectory) throws IOException {
         return bundles;
     }
 
+    static void checkForFailedPluginRemovals(final Path pluginsDirectory) throws IOException {
+        /*
+         * Check for the existence of a marker file that indicates any plugins are in a garbage state from a failed attempt to remove the
+         * plugin.
+         */
+        try (DirectoryStream<Path> stream = Files.newDirectoryStream(pluginsDirectory, ".removing-*")) {
+            final Iterator<Path> iterator = stream.iterator();
+            if (iterator.hasNext()) {
+                final Path removing = iterator.next();
+                final String fileName = removing.getFileName().toString();
+                final String name = fileName.substring(1 + fileName.indexOf("-"));
+                final String message = String.format(
+                        Locale.ROOT,
+                        "found file [%s] from a failed attempt to remove the plugin [%s]; execute [elasticsearch-plugin remove %2$s]",
+                        removing,
+                        name);
+                throw new IllegalStateException(message);
+            }
+        }
+    }
+
     static Set<Bundle> getPluginBundles(Path pluginsDirectory) throws IOException {
         Logger logger = Loggers.getLogger(PluginsService.class);
 
@@ -298,6 +321,8 @@ static Set<Bundle> getPluginBundles(Path pluginsDirectory) throws IOException {
 
         Set<Bundle> bundles = new LinkedHashSet<>();
 
+        checkForFailedPluginRemovals(pluginsDirectory);
+
         try (DirectoryStream<Path> stream = Files.newDirectoryStream(pluginsDirectory)) {
             for (Path plugin : stream) {
                 logger.trace("--- adding plugin [{}]", plugin.toAbsolutePath());
@@ -308,19 +333,6 @@ static Set<Bundle> getPluginBundles(Path pluginsDirectory) throws IOException {
                     throw new IllegalStateException("Could not load plugin descriptor for existing plugin ["
                         + plugin.getFileName() + "]. Was the plugin built before 2.0?", e);
                 }
-                /*
-                 * Check for the existence of a marker file that indicates the plugin is in a garbage state from a failed attempt to remove
-                 * the plugin.
-                 */
-                final Path removing = plugin.resolve(".removing-" + info.getName());
-                if (Files.exists(removing)) {
-                    final String message = String.format(
-                            Locale.ROOT,
-                            "found file [%s] from a failed attempt to remove the plugin [%s]; execute [elasticsearch-plugin remove %2$s]",
-                            removing,
-                            info.getName());
-                    throw new IllegalStateException(message);
-                }
 
                 Set<URL> urls = new LinkedHashSet<>();
                 try (DirectoryStream<Path> jarStream = Files.newDirectoryStream(plugin, "*.jar")) {

core/src/test/java/org/elasticsearch/plugins/PluginsServiceTests.java

@@ -132,8 +132,8 @@ public void testStartupWithRemovingMarker() throws IOException {
         final Path fake = home.resolve("plugins").resolve("fake");
         Files.createDirectories(fake);
         Files.createFile(fake.resolve("plugin.jar"));
-        final Path removing = fake.resolve(".removing-fake");
-        Files.createFile(fake.resolve(".removing-fake"));
+        final Path removing = home.resolve("plugins").resolve(".removing-fake");
+        Files.createFile(removing);
         PluginTestUtil.writeProperties(
                 fake,
                 "description", "fake",

distribution/tools/plugin-cli/src/main/java/org/elasticsearch/plugins/InstallPluginCommand.java

@@ -485,6 +485,8 @@ private PluginInfo verify(Terminal terminal, Path pluginRoot, boolean isBatch, E
             throw new UserException(PLUGIN_EXISTS, message);
         }
 
+        PluginsService.checkForFailedPluginRemovals(env.pluginsFile());
+
         terminal.println(VERBOSE, info.toString());
 
         // don't let user install plugin as a module...

distribution/tools/plugin-cli/src/main/java/org/elasticsearch/plugins/RemovePluginCommand.java

@@ -26,14 +26,14 @@
 import org.elasticsearch.cli.ExitCodes;
 import org.elasticsearch.cli.Terminal;
 import org.elasticsearch.cli.UserException;
-import org.elasticsearch.common.Strings;
 import org.elasticsearch.env.Environment;
 
 import java.io.IOException;
 import java.nio.file.FileAlreadyExistsException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
 import java.util.stream.Collectors;
@@ -46,75 +46,113 @@
  */
 class RemovePluginCommand extends EnvironmentAwareCommand {
 
+    private final OptionSpec<Void> purgeOption;
     private final OptionSpec<String> arguments;
 
     RemovePluginCommand() {
         super("removes a plugin from Elasticsearch");
+        this.purgeOption = parser.acceptsAll(Arrays.asList("p", "purge"), "Purge plugin configuration files");
         this.arguments = parser.nonOptions("plugin name");
     }
 
     @Override
-    protected void execute(final Terminal terminal, final OptionSet options, final Environment env)
-            throws Exception {
+    protected void execute(final Terminal terminal, final OptionSet options, final Environment env) throws Exception {
         final String pluginName = arguments.value(options);
-        execute(terminal, pluginName, env);
+        final boolean purge = options.has(purgeOption);
+        execute(terminal, env, pluginName, purge);
     }
 
     /**
      * Remove the plugin specified by {@code pluginName}.
      *
      * @param terminal   the terminal to use for input/output
-     * @param pluginName the name of the plugin to remove
      * @param env        the environment for the local node
+     * @param pluginName the name of the plugin to remove
+     * @param purge      if true, plugin configuration files will be removed but otherwise preserved
      * @throws IOException   if any I/O exception occurs while performing a file operation
      * @throws UserException if plugin name is null
      * @throws UserException if plugin directory does not exist
      * @throws UserException if the plugin bin directory is not a directory
      */
-    void execute(final Terminal terminal, final String pluginName, final Environment env)
-            throws IOException, UserException {
+    void execute(
+            final Terminal terminal,
+            final Environment env,
+            final String pluginName,
+            final boolean purge) throws IOException, UserException {
         if (pluginName == null) {
             throw new UserException(ExitCodes.USAGE, "plugin name is required");
         }
 
-        terminal.println("-> removing [" + Strings.coalesceToEmpty(pluginName) + "]...");
+        terminal.println("-> removing [" + pluginName + "]...");
 
         final Path pluginDir = env.pluginsFile().resolve(pluginName);
-        if (Files.exists(pluginDir) == false) {
+        final Path pluginConfigDir = env.configFile().resolve(pluginName);
+        final Path removing = env.pluginsFile().resolve(".removing-" + pluginName);
+        /*
+         * If the plugin does not exist and the plugin config does not exist, fail to the user that the plugin is not found, unless there's
+         * a marker file left from a previously failed attempt in which case we proceed to clean up the marker file. Or, if the plugin does
+         * not exist, the plugin config does, and we are not purging, again fail to the user that the plugin is not found.
+         */
+        if ((!Files.exists(pluginDir) && !Files.exists(pluginConfigDir) && !Files.exists(removing))
+                || (!Files.exists(pluginDir) && Files.exists(pluginConfigDir) && !purge)) {
             final String message = String.format(
-                    Locale.ROOT,
-                    "plugin [%s] not found; "
-                            + "run 'elasticsearch-plugin list' to get list of installed plugins",
-                    pluginName);
+                    Locale.ROOT, "plugin [%s] not found; run 'elasticsearch-plugin list' to get list of installed plugins", pluginName);
             throw new UserException(ExitCodes.CONFIG, message);
         }
 
         final List<Path> pluginPaths = new ArrayList<>();
 
+        /*
+         * Add the contents of the plugin directory before creating the marker file and adding it to the list of paths to be deleted so
+         * that the marker file is the last file to be deleted.
+         */
+        if (Files.exists(pluginDir)) {
+            try (Stream<Path> paths = Files.list(pluginDir)) {
+                pluginPaths.addAll(paths.collect(Collectors.toList()));
+            }
+            terminal.println(VERBOSE, "removing [" + pluginDir + "]");
+        }
+
         final Path pluginBinDir = env.binFile().resolve(pluginName);
         if (Files.exists(pluginBinDir)) {
-            if (Files.isDirectory(pluginBinDir) == false) {
-                throw new UserException(
-                        ExitCodes.IO_ERROR, "bin dir for " + pluginName + " is not a directory");
+            if (!Files.isDirectory(pluginBinDir)) {
+                throw new UserException(ExitCodes.IO_ERROR, "bin dir for " + pluginName + " is not a directory");
+            }
+            try (Stream<Path> paths = Files.list(pluginBinDir)) {
+                pluginPaths.addAll(paths.collect(Collectors.toList()));
             }
             pluginPaths.add(pluginBinDir);
             terminal.println(VERBOSE, "removing [" + pluginBinDir + "]");
         }
 
-        terminal.println(VERBOSE, "removing [" + pluginDir + "]");
-         /*
+        if (Files.exists(pluginConfigDir)) {
+            if (purge) {
+                try (Stream<Path> paths = Files.list(pluginConfigDir)) {
+                    pluginPaths.addAll(paths.collect(Collectors.toList()));
+                }
+                pluginPaths.add(pluginConfigDir);
+                terminal.println(VERBOSE, "removing [" + pluginConfigDir + "]");
+            } else {
+                /*
+                 * By default we preserve the config files in case the user is upgrading the plugin, but we print a message so the user
+                 * knows in case they want to remove manually.
+                 */
+                final String message = String.format(
+                        Locale.ROOT,
+                        "-> preserving plugin config files [%s] in case of upgrade; use --purge if not needed",
+                        pluginConfigDir);
+                terminal.println(message);
+            }
+        }
+
+        /*
          * We are going to create a marker file in the plugin directory that indicates that this plugin is a state of removal. If the
          * removal fails, the existence of this marker file indicates that the plugin is in a garbage state. We check for existence of this
-         * marker file during startup so that we do not startup with plugins in such a garbage state.
+         * marker file during startup so that we do not startup with plugins in such a garbage state. Up to this point, we have not done
+         * anything destructive, so we create the marker file as the last action before executing destructive operations. We place this
+         * marker file in the root plugin directory (not the specific plugin directory) so that we do not have to create the specific plugin
+         * directory if it does not exist (we are purging configuration files).
          */
-        final Path removing = pluginDir.resolve(".removing-" + pluginName);
-        /*
-         * Add the contents of the plugin directory before creating the marker file and adding it to the list of paths to be deleted so
-         * that the marker file is the last file to be deleted.
-         */
-        try (Stream<Path> paths = Files.list(pluginDir)) {
-            pluginPaths.addAll(paths.collect(Collectors.toList()));
-        }
         try {
             Files.createFile(removing);
         } catch (final FileAlreadyExistsException e) {
@@ -124,24 +162,14 @@ void execute(final Terminal terminal, final String pluginName, final Environment
              */
             terminal.println(VERBOSE, "marker file [" + removing + "] already exists");
         }
-        // now add the marker file
-        pluginPaths.add(removing);
-        // finally, add the plugin directory
+
+        // add the plugin directory
         pluginPaths.add(pluginDir);
-        IOUtils.rm(pluginPaths.toArray(new Path[pluginPaths.size()]));
 
-        /*
-         * We preserve the config files in case the user is upgrading the plugin, but we print a
-         * message so the user knows in case they want to remove manually.
-         */
-        final Path pluginConfigDir = env.configFile().resolve(pluginName);
-        if (Files.exists(pluginConfigDir)) {
-            final String message = String.format(
-                    Locale.ROOT,
-                    "-> preserving plugin config files [%s] in case of upgrade; delete manually if not needed",
-                    pluginConfigDir);
-            terminal.println(message);
-        }
+        // finally, add the marker file
+        pluginPaths.add(removing);
+
+        IOUtils.rm(pluginPaths.toArray(new Path[pluginPaths.size()]));
     }
 
 }