/*
 * Licensed to Elasticsearch under one or more contributor
 * license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright
 * ownership. Elasticsearch licenses this file to you under
 * the Apache License, Version 2.0 (the "License"); you may
 * not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.elasticsearch.plugins;

import joptsimple.OptionSet;
import joptsimple.OptionSpec;
import org.apache.lucene.util.IOUtils;
import org.elasticsearch.cli.EnvironmentAwareCommand;
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.List;
import java.util.Locale;

import static org.elasticsearch.cli.Terminal.Verbosity.VERBOSE;

/**
 * A command for the plugin CLI to remove a plugin from Elasticsearch.
 */
class RemovePluginCommand extends EnvironmentAwareCommand {

    private final OptionSpec<String> arguments;

    RemovePluginCommand() {
        super("removes a plugin from Elasticsearch");
        this.arguments = parser.nonOptions("plugin name");
    }

    @Override
    protected void execute(final Terminal terminal, final OptionSet options, final Environment env)
            throws Exception {
        final String pluginName = arguments.value(options);
        execute(terminal, pluginName, env);
    }

    /**
     * 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
     * @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 {
        if (pluginName == null) {
            throw new UserException(ExitCodes.USAGE, "plugin name is required");
        }

        terminal.println("-> removing [" + Strings.coalesceToEmpty(pluginName) + "]...");

        final Path pluginDir = env.pluginsFile().resolve(pluginName);
        if (Files.exists(pluginDir) == false) {
            final String message = String.format(
                    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<>();

        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");
            }
            pluginPaths.add(pluginBinDir);
            terminal.println(VERBOSE, "removing [" + pluginBinDir + "]");
        }

        terminal.println(VERBOSE, "removing [" + pluginDir + "]");
         /*
         * 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.
         */
        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.
         */
        Files.list(pluginDir).forEach(pluginPaths::add);
        try {
            Files.createFile(removing);
        } catch (final FileAlreadyExistsException e) {
            /*
             * We need to suppress the marker file already existing as we could be in this state if a previous removal attempt failed and
             * the user is attempting to remove the plugin again.
             */
            terminal.println(VERBOSE, "marker file [" + removing + "] already exists");
        }
        // now add the marker file
        pluginPaths.add(removing);
        IOUtils.rm(pluginPaths.toArray(new Path[pluginPaths.size()]));
        // at this point, the plugin directory is empty and we can execute a simple directory removal
        Files.delete(pluginDir);

        /*
         * 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);
        }
    }

}

@@ -1385,16 +1385,84 @@
 .Locale;
+%0Aimport java.util.stream.Collectors;%0Aimport java.util.stream.Stream;
 %0A%0Aimport
@@ -4745,24 +4745,50 @@
   */%0A       
+ try (Stream%3CPath%3E paths =
  Files.list(
@@ -4801,17 +4801,24 @@
 Dir)
-.forEach(
+) %7B%0A            
 plug
@@ -4828,15 +4828,62 @@
 aths
-::add);
+.addAll(paths.collect(Collectors.toList()));%0A        %7D
 %0A   
@@ -5403,207 +5403,154 @@
     
-IOUtils.rm(pluginPaths.toArray(new Path%5BpluginPaths.size()%5D));%0A        // at this point, the plugin directory is empty and we can execute a simple directory removal%0A        Files.delete(pluginDir
+// finally, add the plugin directory%0A        pluginPaths.add(pluginDir);%0A        IOUtils.rm(pluginPaths.toArray(new Path%5BpluginPaths.size()%5D)
 );%0A%0A
+%0A
     

Fix delete of plugin directory on remove plugin