VisualSapfor/src/_VisualDVM/Passes/All/RefreshDVMPackageResults.java

package _VisualDVM.Passes.All;
import Common.CommonConstants;
import Common.Utils.Utils_;
import _VisualDVM.Constants;
import _VisualDVM.Global;
import _VisualDVM.GlobalData.Tasks.TaskState;
import _VisualDVM.Passes.Server.TestingServerPass;
import _VisualDVM.Repository.Server.ServerCode;
import _VisualDVM.TestingSystem.Common.TasksPackageState;
import _VisualDVM.TestingSystem.DVM.DVMPackage.DVMPackage;
import _VisualDVM.TestingSystem.DVM.DVMTasks.DVMCompilationTask;
import _VisualDVM.TestingSystem.DVM.DVMTasks.DVMRunTask;
import _VisualDVM.Utils;
import javafx.util.Pair;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.Vector;
public class RefreshDVMPackageResults extends TestingServerPass<DVMPackage> {
    @Override
    public String getIconPath() {
        return "/icons/Menu/Undo.png";
    }
    @Override
    protected boolean needsAnimation() {
        return true;
    }
    @Override
    protected boolean canStart(Object... args) throws Exception {
        if (!Global.testingServer.db.dvmPackages.getUI().CheckCurrent(Log))
            return false;
        target = Global.testingServer.db.dvmPackages.getUI().getCurrent();
        if (!new File(target.getLocalWorkspace(), CommonConstants.LOADED).exists()) {
            Log.Writeln_("Пакет не загружен!");
            return false;
        }
        return true;
    }
    @Override
    protected void body() throws Exception {
        boolean hasErrors = false;
        target.readJson();
        Vector<DVMRunTask> runTasks = new Vector<>();
        for (DVMCompilationTask compilationTask : target.package_json.compilationTasks)
            runTasks.addAll(compilationTask.runTasks);
        //----
        int ct_count = 0;
        int rt_count = 0;
        int good = 0;
        //--
        int i = 0;
        for (DVMCompilationTask compilationTask : target.package_json.compilationTasks)
            for (DVMRunTask runTask : compilationTask.runTasks) {
                ShowProgress(runTasks.size(), i, true);
                rt_count++;
                if (compilationTask.state != TaskState.Done) {
                    runTask.state = TaskState.Canceled;
                } else {
                    File rt_workspace = Paths.get(target.getLocalWorkspace().getAbsolutePath(), "results", String.valueOf(runTask.id)).toFile();
                    if (rt_workspace.exists()) {
                        //анализ задачи на запуск.
                        File outFile = new File(rt_workspace, Constants.out_file);
                        File errFile = new File(rt_workspace.getAbsolutePath(), Constants.err_file);
                        //--
                        String output = FileUtils.readFileToString(outFile);
                        String errors = FileUtils.readFileToString(errFile);
                        //--
                        List<String> output_lines = Arrays.asList(output.split("\n"));
                        List<String> errors_lines = Arrays.asList(errors.split("\n"));
                        //---
                        if (output.trim().isEmpty()) {
                            runTask.state = TaskState.Crushed;
                        } else {
                            if (Utils.isCrushed(output_lines, errors_lines)) {
                                runTask.state = TaskState.Crushed;
                            } else {
                                Pair<TaskState, Integer> results = new Pair<>(TaskState.Done, 100);
                                switch (runTask.test_type) {
                                    case Correctness:
                                        results = Utils.analyzeCorrectness(output_lines);
                                        break;
                                    case Performance:
                                        results = Utils.analyzePerformance(output_lines);
                                        break;
                                    default:
                                        break;
                                }
                                runTask.state = results.getKey();
                                runTask.progress = results.getValue();
                                runTask.CleanTime = Utils.parseCleanTime(output);
                            }
                        }
                    }
                }
                if (!runTask.state.equals(TaskState.Done))
                    hasErrors = true;
                else good++;
            }
        //--
        target.saveJson(); //запись обновленных результатов пакета в json!
        target.state = hasErrors ? TasksPackageState.DoneWithErrors : TasksPackageState.Done;
        double percent = (((double) (good)) / target.tasksCount) * 100.0;
        target.description = "Выполнено на " + ((int) percent) + "%\n" +
                "Всего задач: " + target.tasksCount + ", из них с ошибками " + (target.tasksCount - good);
        //--
    }
    @Override
    protected void performDone() throws Exception {
        SendRequest(ServerCode.ReplaceDVMPackageResults,"",
                new Pair<>(
                        target,
                        Utils_.fileToBytes(target.getJsonFile())
                )
        );
    }
}