MapCheckerScriptChecker.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2023 The Gridarta Developers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package net.sf.gridarta.model.validation.checks;
 
import java.awt.Point;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.io.MapWriter;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapSquare;
import net.sf.gridarta.model.validation.AbstractValidator;
import net.sf.gridarta.model.validation.ErrorCollector;
import net.sf.gridarta.model.validation.MapValidator;
import net.sf.gridarta.model.validation.ValidatorPreferences;
import net.sf.gridarta.utils.CopyReader;
import net.sf.gridarta.utils.IOUtils;
import net.sf.gridarta.utils.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class MapCheckerScriptChecker<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> extends AbstractValidator<G, A, R> implements MapValidator<G, A, R> {
 
    private static final int MAX_EXEC_TIME = 30000;
 
    @NotNull
    public static final String MAP_PLACEHOLDER = "${MAP}";
 
    @NotNull
    private static final String QUOTED_MAP_PLACEHOLDER = Pattern.quote(MAP_PLACEHOLDER);
 
    @NotNull
    public static final String REAL_MAP_PLACEHOLDER = "${REAL_MAP}";
 
    @NotNull
    private static final String QUOTED_REAL_MAP_PLACEHOLDER = Pattern.quote(REAL_MAP_PLACEHOLDER);
 
    @NotNull
    private static final Pattern PATTERN_MAP_SQUARE_MESSAGE = Pattern.compile("(\\d+)\\s+(\\d+)\\s+(.*)");
 
    @NotNull
    private final MapWriter<G, A, R> mapWriter;
 
    @NotNull
    private final CommandFinder commandFinder1 = new CommandFinder();
 
    @NotNull
    private final CommandFinder commandFinder2 = new CommandFinder();
 
    @NotNull
    private final String @NotNull [] args;
 
    @Nullable
    private File tmpFile;
 
    public MapCheckerScriptChecker(@NotNull final ValidatorPreferences validatorPreferences, @NotNull final MapWriter<G, A, R> mapWriter, @NotNull final String @NotNull [] args) {
        super(validatorPreferences);
        this.mapWriter = mapWriter;
        this.args = args.clone();
 
        if (this.args.length < 1) {
            throw new IllegalArgumentException("no script to execute");
        }
 
        boolean found = false;
        for (int i = 1; i < this.args.length; i++) {
            if (this.args[i].contains(MAP_PLACEHOLDER)) {
                found = true;
                break;
            }
        }
        if (!found) {
            throw new IllegalArgumentException("the script to execute doesn't receive the map to check (" + MAP_PLACEHOLDER + ")");
        }
    }
 
    @Override
    public void validateMap(@NotNull final MapModel<G, A, R> mapModel, @NotNull final ErrorCollector<G, A, R> errorCollector) {
        final String[] command = getCommand(mapModel, errorCollector);
        if (command == null) {
            return;
        }
        final Process process;
        try {
            process = Runtime.getRuntime().exec(command);
        } catch (final IOException ex) {
            errorCollector.collect(new MapCheckerScriptMissingError<>(mapModel, command[0], ex.getMessage()));
            return;
        }
        @Nullable final String output;
        try {
            try {
                process.getOutputStream().close();
            } catch (final IOException ex) {
                errorCollector.collect(new MapCheckerScriptFailureError<>(mapModel, command[0], ex.getMessage() + " (closing stdin)"));
                return;
            }
 
            output = runProcess(process, errorCollector, mapModel, command[0]);
        } finally {
            process.destroy();
        }
        if (output != null) {
            parseOutput(output, errorCollector, mapModel, command[0]);
        }
    }
 
    private void parseOutput(@NotNull final CharSequence output, @NotNull final ErrorCollector<G, A, R> errorCollector, @NotNull final MapModel<G, A, R> mapModel, @NotNull final String command) {
        final String[] lines = StringUtils.PATTERN_END_OF_LINE.split(output);
        for (final String line : lines) {
            if (!line.isEmpty()) {
                final Matcher matcher = PATTERN_MAP_SQUARE_MESSAGE.matcher(line);
                if (matcher.matches()) {
                    final int x;
                    final int y;
                    try {
                        x = Integer.parseInt(matcher.group(1));
                        y = Integer.parseInt(matcher.group(2));
                    } catch (final NumberFormatException ignored) {
                        errorCollector.collect(new MapCheckerScriptFailureError<>(mapModel, command, "syntax error in '" + line + "'"));
                        continue;
                    }
                    final String message = matcher.group(3);
                    final MapSquare<G, A, R> mapSquare;
                    try {
                        mapSquare = mapModel.getMapSquare(new Point(x, y));
                    } catch (final IndexOutOfBoundsException ignored) {
                        errorCollector.collect(new MapCheckerScriptFailureError<>(mapModel, command, "invalid map square in '" + line + "'"));
                        continue;
                    }
                    errorCollector.collect(new MapCheckerScriptMapSquareError<>(mapSquare, message));
                } else {
                    errorCollector.collect(new MapCheckerScriptMapError<>(mapModel, line));
                }
            }
        }
    }
 
    @Nullable
    private String runProcess(@NotNull final Process process, @NotNull final ErrorCollector<G, A, R> errorCollector, @NotNull final MapModel<G, A, R> mapModel, @NotNull final String command) {
        @Nullable String output;
        final InputStreamReader stdoutReader = new InputStreamReader(process.getInputStream());
        try {
            final CopyReader stdout = new CopyReader(stdoutReader);
            final InputStreamReader stderrReader = new InputStreamReader(process.getErrorStream());
            try {
                final CopyReader stderr = new CopyReader(stderrReader);
                stdout.start();
                try {
                    stderr.start();
                    try {
                        if (!waitForTermination(process, errorCollector, mapModel, command, stdout, stderr)) {
                            return null;
                        }
                    } finally {
                        stderr.stop();
                    }
                } finally {
                    stdout.stop();
                }
            } finally {
                try {
                    stderrReader.close();
                } catch (final IOException ex) {
                    errorCollector.collect(new MapCheckerScriptFailureError<>(mapModel, command, ex.getMessage() + " (closing stderr)"));
                }
            }
            final String stdoutFailure = stdout.getFailure();
            if (stdoutFailure != null) {
                errorCollector.collect(new MapCheckerScriptFailureError<>(mapModel, command, stdoutFailure));
                return null;
            }
            output = stdout.getOutput();
        } finally {
            try {
                stdoutReader.close();
            } catch (final IOException ex) {
                errorCollector.collect(new MapCheckerScriptFailureError<>(mapModel, command, ex.getMessage() + " (closing stdout)"));
            }
        }
        return output;
    }
 
    private boolean waitForTermination(@NotNull final Process process, @NotNull final ErrorCollector<G, A, R> errorCollector, @NotNull final MapModel<G, A, R> mapModel, @NotNull final String command, @NotNull final CopyReader stdout, @NotNull final CopyReader stderr) {
        final Semaphore sem = new Semaphore(0);
        final int[] tmp = { -1, };
        final Runnable runnable = () -> {
            try {
                try {
                    stdout.join();
                    stderr.join();
                    tmp[0] = process.waitFor();
                } catch (final InterruptedException ignored) {
                    Thread.currentThread().interrupt();
                }
            } finally {
                sem.release();
            }
        };
        final Thread thread = new Thread(runnable);
        thread.start();
        try {
            if (!sem.tryAcquire(MAX_EXEC_TIME, TimeUnit.MILLISECONDS)) {
                errorCollector.collect(new MapCheckerScriptFailureError<>(mapModel, command, "timeout waiting for script to terminate"));
                return false;
            }
        } catch (final InterruptedException ignored) {
            errorCollector.collect(new MapCheckerScriptFailureError<>(mapModel, command, "interrupted waiting for script to terminate"));
            return false;
        }
        thread.interrupt();
        if (tmp[0] != 0) {
            errorCollector.collect(new MapCheckerScriptFailureError<>(mapModel, command, "command exited with status " + tmp[0]));
            return false;
        }
        final String stderrFailure = stderr.getFailure();
        if (stderrFailure != null) {
            errorCollector.collect(new MapCheckerScriptFailureError<>(mapModel, command, stderrFailure));
            return false;
        }
        final String stderrOutput = stderr.getOutput();
        if (!stderrOutput.isEmpty()) {
            errorCollector.collect(new MapCheckerScriptFailureError<>(mapModel, command, StringUtils.PATTERN_NEWLINE.matcher(stderrOutput).replaceAll("<br>")));
            return false;
        }
        return true;
    }
 
    @NotNull
    private String @Nullable [] getCommand(@NotNull final MapModel<G, A, R> mapModel, @NotNull final ErrorCollector<G, A, R> errorCollector) {
        if (tmpFile == null) {
            try {
                tmpFile = File.createTempFile("gridarta", null);
            } catch (final IOException ex) {
                errorCollector.collect(new MapCheckerScriptIOError<>(mapModel, "create temporary file", ex.getMessage()));
                return null;
            }
            assert tmpFile != null;
            tmpFile.deleteOnExit();
        }
        assert tmpFile != null;
        final String mapPath = tmpFile.getPath();
        final String realMapPath = mapModel.getMapFile() == null ? "" : mapModel.getMapFile().toString();
        try {
            try (OutputStream outputStream = new FileOutputStream(tmpFile)) {
                try (Writer writer = new OutputStreamWriter(outputStream, IOUtils.MAP_ENCODING)) {
                    mapWriter.encodeMapFile(mapModel, writer);
                }
            }
        } catch (final IOException ex) {
            errorCollector.collect(new MapCheckerScriptIOError<>(mapModel, mapPath, ex.getMessage()));
            return null;
        }
 
        final boolean isWindows = System.getProperty("os.name").contains("Windows");
        final String[] result;
        int index = 0;
        try {
            if (isWindows) {
                if (args[0].toLowerCase().endsWith(".py")) {
                    result = new String[args.length + 1];
                    String command;
                    try {
                        command = commandFinder2.getCommand("python.exe");
                    } catch (final IOException ex) {
                        command = "C:" + File.separator + "python34" + File.separator + "python.exe";
                        if (!new File(command).exists()) {
                            throw ex;
                        }
                    }
                    result[index++] = "\"" + command + "\"";
                } else {
                    result = new String[args.length];
                }
                result[index++] = "\"" + commandFinder1.getCommand(args[0]) + "\"";
            } else {
                result = new String[args.length];
                result[index++] = commandFinder1.getCommand(args[0]);
            }
        } catch (final IOException ex) {
            errorCollector.collect(new MapCheckerScriptMissingError<>(mapModel, args[0], ex.getMessage()));
            return null;
        }
        final String mapPathQuoted = Matcher.quoteReplacement(mapPath);
        final String realMapPathQuoted = Matcher.quoteReplacement(realMapPath);
        for (int i = 1; i < args.length; i++) {
            final String tmp = args[i].replaceAll(QUOTED_MAP_PLACEHOLDER, mapPathQuoted).replaceAll(QUOTED_REAL_MAP_PLACEHOLDER, realMapPathQuoted);
            result[index++] = isWindows ? "\"" + tmp + "\"" : tmp;
        }
        return result;
    }
 
    private static class CommandFinder {
 
        @Nullable
        private File cachedCommand;
 
        @NotNull
        private String getCommand(@NotNull final String commandName) throws IOException {
            final File existingCommand = cachedCommand;
            if (existingCommand != null && existingCommand.exists()) {
                return existingCommand.getPath();
            }
 
            final File command = IOUtils.findPathFile(commandName);
            cachedCommand = command;
            return command.getPath();
        }
 
    }
 
}