# Source code
source: package: co.aikar.commands, class: BukkitCommandManager

    001/*
    002 * Copyright (c) 2016-2017 Daniel Ennis (Aikar) - MIT License
    003 *
    004 *  Permission is hereby granted, free of charge, to any person obtaining
    005 *  a copy of this software and associated documentation files (the
    006 *  "Software"), to deal in the Software without restriction, including
    007 *  without limitation the rights to use, copy, modify, merge, publish,
    008 *  distribute, sublicense, and/or sell copies of the Software, and to
    009 *  permit persons to whom the Software is furnished to do so, subject to
    010 *  the following conditions:
    011 *
    012 *  The above copyright notice and this permission notice shall be
    013 *  included in all copies or substantial portions of the Software.
    014 *
    015 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    016 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    017 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
    018 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
    019 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
    020 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
    021 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    022 */
    023
    024package co.aikar.commands;
    025
    026import co.aikar.commands.apachecommonslang.ApacheCommonsExceptionUtil;
    027import co.aikar.timings.lib.TimingManager;
    028import org.bukkit.Bukkit;
    029import org.bukkit.ChatColor;
    030import org.bukkit.Server;
    031import org.bukkit.command.Command;
    032import org.bukkit.command.CommandException;
    033import org.bukkit.command.CommandMap;
    034import org.bukkit.command.CommandSender;
    035import org.bukkit.command.PluginIdentifiableCommand;
    036import org.bukkit.command.SimpleCommandMap;
    037import org.bukkit.configuration.file.FileConfiguration;
    038import org.bukkit.entity.Player;
    039import org.bukkit.help.GenericCommandHelpTopic;
    040import org.bukkit.inventory.ItemFactory;
    041import org.bukkit.plugin.Plugin;
    042import org.bukkit.plugin.PluginDescriptionFile;
    043import org.bukkit.plugin.PluginManager;
    044import org.bukkit.plugin.java.JavaPlugin;
    045import org.bukkit.scoreboard.ScoreboardManager;
    046import org.jetbrains.annotations.NotNull;
    047
    048import java.lang.reflect.Field;
    049import java.lang.reflect.Method;
    050import java.util.Collection;
    051import java.util.Collections;
    052import java.util.HashMap;
    053import java.util.HashSet;
    054import java.util.List;
    055import java.util.Locale;
    056import java.util.Map;
    057import java.util.Objects;
    058import java.util.UUID;
    059import java.util.concurrent.ConcurrentHashMap;
    060import java.util.logging.Level;
    061import java.util.logging.Logger;
    062import java.util.regex.Matcher;
    063import java.util.regex.Pattern;
    064
    065@SuppressWarnings("WeakerAccess")
    066public class BukkitCommandManager extends CommandManager<
    067        CommandSender,
    068        BukkitCommandIssuer,
    069        ChatColor,
    070        BukkitMessageFormatter,
    071        BukkitCommandExecutionContext,
    072        BukkitConditionContext
    073        > {
    074
    075    @SuppressWarnings("WeakerAccess")
    076    protected final Plugin plugin;
    077    private final CommandMap commandMap;
    078    @Deprecated
    079    private final TimingManager timingManager;
    080    private ACFBukkitScheduler scheduler;
    081    private final Logger logger;
    082    public final Integer mcMinorVersion;
    083    public final Integer mcPatchVersion;
    084    protected Map<String, Command> knownCommands = new HashMap<>();
    085    protected Map<String, BukkitRootCommand> registeredCommands = new HashMap<>();
    086    protected BukkitCommandContexts contexts;
    087    protected BukkitCommandCompletions completions;
    088    protected BukkitLocales locales;
    089    protected Map<UUID, String> issuersLocaleString = new ConcurrentHashMap<>();
    090    private boolean cantReadLocale = false;
    091    protected boolean autoDetectFromClient = true;
    092
    093    public BukkitCommandManager(Plugin plugin) {
    094        this.plugin = plugin;
    095
    096        //See what schedule we should use, bukkit or folia
    097        try {
    098            Class.forName("io.papermc.paper.threadedregions.scheduler.AsyncScheduler");
    099            this.scheduler = new ACFFoliaScheduler();
    100        } catch (ClassNotFoundException ignored) {
    101            this.scheduler = new ACFBukkitScheduler();
    102        }
    103
    104        String prefix = this.plugin.getDescription().getPrefix();
    105        this.logger = Logger.getLogger(prefix != null ? prefix : this.plugin.getName());
    106        this.timingManager = TimingManager.of(plugin);
    107        this.commandMap = hookCommandMap();
    108        this.formatters.put(MessageType.ERROR, defaultFormatter = new BukkitMessageFormatter(ChatColor.RED, ChatColor.YELLOW, ChatColor.RED));
    109        this.formatters.put(MessageType.SYNTAX, new BukkitMessageFormatter(ChatColor.YELLOW, ChatColor.GREEN, ChatColor.WHITE));
    110        this.formatters.put(MessageType.INFO, new BukkitMessageFormatter(ChatColor.BLUE, ChatColor.DARK_GREEN, ChatColor.GREEN));
    111        this.formatters.put(MessageType.HELP, new BukkitMessageFormatter(ChatColor.AQUA, ChatColor.GREEN, ChatColor.YELLOW));
    112        Pattern versionPattern = Pattern.compile("\\(MC: (\\d)\\.(\\d+)\\.?(\\d+?)?\\)");
    113        Matcher matcher = versionPattern.matcher(Bukkit.getVersion());
    114        if (matcher.find()) {
    115            this.mcMinorVersion = ACFUtil.parseInt(matcher.toMatchResult().group(2), 0);
    116            this.mcPatchVersion = ACFUtil.parseInt(matcher.toMatchResult().group(3), 0);
    117        } else {
    118            this.mcMinorVersion = -1;
    119            this.mcPatchVersion = -1;
    120        }
    121        Bukkit.getHelpMap().registerHelpTopicFactory(BukkitRootCommand.class, command -> {
    122            if (hasUnstableAPI("help")) {
    123                return new ACFBukkitHelpTopic(this, (BukkitRootCommand) command);
    124            } else {
    125                return new GenericCommandHelpTopic(command);
    126            }
    127        });
    128
    129        Bukkit.getPluginManager().registerEvents(new ACFBukkitListener(this, plugin), plugin);
    130
    131        getLocales(); // auto load locales
    132        scheduler.createLocaleTask(plugin, () -> {
    133            if (this.cantReadLocale || !this.autoDetectFromClient) {
    134                return;
    135            }
    136            Bukkit.getOnlinePlayers().forEach(this::readPlayerLocale);
    137        }, 30, 30);
    138
    139        this.validNamePredicate = ACFBukkitUtil::isValidName;
    140
    141        registerDependency(plugin.getClass(), plugin);
    142        registerDependency(Logger.class, plugin.getLogger());
    143        registerDependency(FileConfiguration.class, plugin.getConfig());
    144        registerDependency(FileConfiguration.class, "config", plugin.getConfig());
    145        registerDependency(Plugin.class, plugin);
    146        registerDependency(JavaPlugin.class, plugin);
    147        registerDependency(PluginManager.class, Bukkit.getPluginManager());
    148        registerDependency(Server.class, Bukkit.getServer());
    149        scheduler.registerSchedulerDependencies(this);
    150        registerDependency(ScoreboardManager.class, Bukkit.getScoreboardManager());
    151        registerDependency(ItemFactory.class, Bukkit.getItemFactory());
    152        registerDependency(PluginDescriptionFile.class, plugin.getDescription());
    153    }
    154
    155    @NotNull
    156    private CommandMap hookCommandMap() {
    157        CommandMap commandMap = null;
    158        try {
    159            Server server = Bukkit.getServer();
    160            Method getCommandMap = server.getClass().getDeclaredMethod("getCommandMap");
    161            getCommandMap.setAccessible(true);
    162            commandMap = (CommandMap) getCommandMap.invoke(server);
    163            if (!SimpleCommandMap.class.isAssignableFrom(commandMap.getClass())) {
    164                this.log(LogLevel.ERROR, "ERROR: CommandMap has been hijacked! Offending command map is located at: " + commandMap.getClass().getName());
    165                this.log(LogLevel.ERROR, "We are going to try to hijack it back and resolve this, but you are now in dangerous territory.");
    166                this.log(LogLevel.ERROR, "We can not guarantee things are going to work.");
    167                Field cmField = server.getClass().getDeclaredField("commandMap");
    168                commandMap = new ProxyCommandMap(this, commandMap);
    169                cmField.set(server, commandMap);
    170                this.log(LogLevel.INFO, "Injected Proxy Command Map... good luck...");
    171            }
    172            Field knownCommands = SimpleCommandMap.class.getDeclaredField("knownCommands");
    173            knownCommands.setAccessible(true);
    174            //noinspection unchecked
    175            this.knownCommands = (Map<String, Command>) knownCommands.get(commandMap);
    176        } catch (Exception e) {
    177            this.log(LogLevel.ERROR, "Failed to get Command Map. ACF will not function.");
    178            ACFUtil.sneaky(e);
    179        }
    180        return commandMap;
    181    }
    182
    183    public Plugin getPlugin() {
    184        return this.plugin;
    185    }
    186
    187    @Override
    188    public boolean isCommandIssuer(Class<?> type) {
    189        return CommandSender.class.isAssignableFrom(type);
    190    }
    191
    192    @Override
    193    public synchronized CommandContexts<BukkitCommandExecutionContext> getCommandContexts() {
    194        if (this.contexts == null) {
    195            this.contexts = new BukkitCommandContexts(this);
    196        }
    197        return contexts;
    198    }
    199
    200    @Override
    201    public synchronized CommandCompletions<BukkitCommandCompletionContext> getCommandCompletions() {
    202        if (this.completions == null) {
    203            this.completions = new BukkitCommandCompletions(this);
    204        }
    205        return completions;
    206    }
    207
    208
    209    @Override
    210    public BukkitLocales getLocales() {
    211        if (this.locales == null) {
    212            this.locales = new BukkitLocales(this);
    213            this.locales.loadLanguages();
    214        }
    215        return locales;
    216    }
    217
    218
    219    @Override
    220    public boolean hasRegisteredCommands() {
    221        return !registeredCommands.isEmpty();
    222    }
    223
    224    public void registerCommand(BaseCommand command, boolean force) {
    225        final String plugin = this.plugin.getName().toLowerCase(Locale.ENGLISH);
    226        command.onRegister(this);
    227        for (Map.Entry<String, RootCommand> entry : command.registeredCommands.entrySet()) {
    228            String commandName = entry.getKey().toLowerCase(Locale.ENGLISH);
    229            BukkitRootCommand bukkitCommand = (BukkitRootCommand) entry.getValue();
    230            if (!bukkitCommand.isRegistered) {
    231                Command oldCommand = commandMap.getCommand(commandName);
    232                if (oldCommand instanceof PluginIdentifiableCommand && ((PluginIdentifiableCommand) oldCommand).getPlugin() == this.plugin) {
    233                    knownCommands.remove(commandName);
    234                    oldCommand.unregister(commandMap);
    235                } else if (oldCommand != null && force) {
    236                    knownCommands.remove(commandName);
    237                    for (Map.Entry<String, Command> ce : knownCommands.entrySet()) {
    238                        String key = ce.getKey();
    239                        Command value = ce.getValue();
    240                        if (key.contains(":") && oldCommand.equals(value)) {
    241                            String[] split = ACFPatterns.COLON.split(key, 2);
    242                            if (split.length > 1) {
    243                                oldCommand.unregister(commandMap);
    244                                oldCommand.setLabel(split[0] + ":" + command.getName());
    245                                oldCommand.register(commandMap);
    246                            }
    247                        }
    248                    }
    249                }
    250                commandMap.register(commandName, plugin, bukkitCommand);
    251            }
    252            bukkitCommand.isRegistered = true;
    253            registeredCommands.put(commandName, bukkitCommand);
    254        }
    255    }
    256
    257    @Override
    258    public void registerCommand(BaseCommand command) {
    259        registerCommand(command, false);
    260    }
    261
    262    public void unregisterCommand(BaseCommand command) {
    263        for (RootCommand rootcommand : command.registeredCommands.values()) {
    264            BukkitRootCommand bukkitCommand = (BukkitRootCommand) rootcommand;
    265            bukkitCommand.getSubCommands().values().removeAll(command.subCommands.values());
    266            if (bukkitCommand.isRegistered && bukkitCommand.getSubCommands().isEmpty()) {
    267                unregisterCommand(bukkitCommand);
    268                bukkitCommand.isRegistered = false;
    269            }
    270        }
    271    }
    272
    273    /**
    274     * @param command
    275     * @deprecated Use unregisterCommand(BaseCommand) - this will be visibility reduced later.
    276     */
    277    @Deprecated
    278    public void unregisterCommand(BukkitRootCommand command) {
    279        final String plugin = this.plugin.getName().toLowerCase(Locale.ENGLISH);
    280        command.unregister(commandMap);
    281        String key = command.getName();
    282        Command registered = knownCommands.get(key);
    283        if (command.equals(registered)) {
    284            knownCommands.remove(key);
    285        }
    286        knownCommands.remove(plugin + ":" + key);
    287        registeredCommands.remove(key);
    288    }
    289
    290    public void unregisterCommands() {
    291        for (String key : new HashSet<>(registeredCommands.keySet())) {
    292            unregisterCommand(registeredCommands.get(key));
    293        }
    294    }
    295
    296
    297    private Field getEntityField(Player player) throws NoSuchFieldException {
    298        Class cls = player.getClass();
    299        while (cls != Object.class) {
    300            if (cls.getName().endsWith("CraftEntity")) {
    301                Field field = cls.getDeclaredField("entity");
    302                field.setAccessible(true);
    303                return field;
    304            }
    305            cls = cls.getSuperclass();
    306        }
    307        return null;
    308    }
    309
    310    public Locale setPlayerLocale(Player player, Locale locale) {
    311        return this.setIssuerLocale(player, locale);
    312    }
    313
    314    void readPlayerLocale(Player player) {
    315        if (!player.isOnline() || cantReadLocale) {
    316            return;
    317        }
    318        try {
    319            Field entityField = getEntityField(player);
    320            if (entityField == null) {
    321                return;
    322            }
    323            Object nmsPlayer = entityField.get(player);
    324            if (nmsPlayer != null) {
    325                Field localeField = nmsPlayer.getClass().getDeclaredField("locale");
    326                localeField.setAccessible(true);
    327                Object localeString = localeField.get(nmsPlayer);
    328                if (localeString instanceof String) {
    329                    UUID playerUniqueId = player.getUniqueId();
    330                    if (!localeString.equals(issuersLocaleString.get(playerUniqueId))) {
    331                        String[] split = ACFPatterns.UNDERSCORE.split((String) localeString);
    332                        Locale locale = split.length > 1 ? new Locale(split[0], split[1]) : new Locale(split[0]);
    333                        Locale prev = issuersLocale.put(playerUniqueId, locale);
    334                        issuersLocaleString.put(playerUniqueId, (String) localeString);
    335                        if (!Objects.equals(locale, prev)) {
    336                            this.notifyLocaleChange(getCommandIssuer(player), prev, locale);
    337                        }
    338                    }
    339                }
    340            }
    341        } catch (Exception e) {
    342            cantReadLocale = true;
    343            this.scheduler.cancelLocaleTask();
    344            this.log(LogLevel.INFO, "Can't read players locale, you will be unable to automatically detect players language. Only Bukkit 1.7+ is supported for this.", e);
    345        }
    346    }
    347
    348    @Deprecated
    349    public TimingManager getTimings() {
    350        return timingManager;
    351    }
    352
    353    public ACFBukkitScheduler getScheduler() {
    354        return scheduler;
    355    }
    356
    357    @Override
    358    public RootCommand createRootCommand(String cmd) {
    359        return new BukkitRootCommand(this, cmd);
    360    }
    361
    362    @Override
    363    public Collection<RootCommand> getRegisteredRootCommands() {
    364        return Collections.unmodifiableCollection(registeredCommands.values());
    365    }
    366
    367    @Override
    368    public BukkitCommandIssuer getCommandIssuer(Object issuer) {
    369        if (!(issuer instanceof CommandSender)) {
    370            throw new IllegalArgumentException(issuer.getClass().getName() + " is not a Command Issuer.");
    371        }
    372        return new BukkitCommandIssuer(this, (CommandSender) issuer);
    373    }
    374
    375    @Override
    376    public BukkitCommandExecutionContext createCommandContext(RegisteredCommand command, CommandParameter parameter, CommandIssuer sender, List<String> args, int i, Map<String, Object> passedArgs) {
    377        return new BukkitCommandExecutionContext(command, parameter, (BukkitCommandIssuer) sender, args, i, passedArgs);
    378    }
    379
    380    @Override
    381    public BukkitCommandCompletionContext createCompletionContext(RegisteredCommand command, CommandIssuer sender, String input, String config, String[] args) {
    382        return new BukkitCommandCompletionContext(command, (BukkitCommandIssuer) sender, input, config, args);
    383    }
    384
    385    @Override
    386    public RegisteredCommand createRegisteredCommand(BaseCommand command, String cmdName, Method method, String prefSubCommand) {
    387        return new BukkitRegisteredCommand(command, cmdName, method, prefSubCommand);
    388    }
    389
    390    @Override
    391    public BukkitConditionContext createConditionContext(CommandIssuer issuer, String config) {
    392        return new BukkitConditionContext((BukkitCommandIssuer) issuer, config);
    393    }
    394
    395
    396    @Override
    397    public void log(LogLevel level, String message, Throwable throwable) {
    398        Level logLevel = level == LogLevel.INFO ? Level.INFO : Level.SEVERE;
    399        logger.log(logLevel, LogLevel.LOG_PREFIX + message);
    400        if (throwable != null) {
    401            for (String line : ACFPatterns.NEWLINE.split(ApacheCommonsExceptionUtil.getFullStackTrace(throwable))) {
    402                logger.log(logLevel, LogLevel.LOG_PREFIX + line);
    403            }
    404        }
    405    }
    406
    407    public boolean usePerIssuerLocale(boolean usePerIssuerLocale, boolean autoDetectFromClient) {
    408        boolean old = this.usePerIssuerLocale;
    409        this.usePerIssuerLocale = usePerIssuerLocale;
    410        this.autoDetectFromClient = autoDetectFromClient;
    411        return old;
    412    }
    413
    414    @Override
    415    public String getCommandPrefix(CommandIssuer issuer) {
    416        return issuer.isPlayer() ? "/" : "";
    417    }
    418
    419    @Override
    420    protected boolean handleUncaughtException(BaseCommand scope, RegisteredCommand registeredCommand, CommandIssuer sender, List<String> args, Throwable t) {
    421        if (t instanceof CommandException && t.getCause() != null && t.getMessage().startsWith("Unhandled exception")) {
    422            t = t.getCause();
    423        }
    424        return super.handleUncaughtException(scope, registeredCommand, sender, args, t);
    425    }
    426}