VisualSapfor/src/TestingSystem/SAPFOR/SapforTestingPlanner.java

package TestingSystem.SAPFOR;
import Common.Constants;
import Common.Current;
import Common.Global;
import Common.GlobalProperties;
import Common.Utils.Utils;
import ProjectData.LanguageName;
import Repository.Component.Sapfor.Sapfor;
import Repository.EmailMessage;
import Repository.Server.ServerCode;
import TestingSystem.Common.TasksPackageState;
import TestingSystem.Common.TestingPlanner;
import TestingSystem.SAPFOR.Json.SapforConfiguration_json;
import TestingSystem.SAPFOR.Json.SapforTest_json;
import TestingSystem.SAPFOR.Json.SapforTestingSet_json;
import TestingSystem.SAPFOR.SapforPackage.SapforPackage;
import TestingSystem.SAPFOR.ServerSapfor.ServerSapfor;
import TestingSystem.SAPFOR.ServerSapfor.ServerSapforState;
import javafx.util.Pair;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.nio.charset.Charset;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Date;
import java.util.Vector;
public class SapforTestingPlanner extends TestingPlanner<SapforPackage> {
    File workspace;
    ServerSapfor sapfor;
    //--
    File repo;
    File repoSapforHome;
    int max_version;
    int current_version;
    //--
    File repo_bin;
    File repo_out;
    File repo_err;
    //--
    public SapforTestingPlanner() {
        repo = new File(Global.Home, "Repo");
        repoSapforHome = Paths.get(Global.Home, "Repo", Constants.SAPFOR_REPOSITORY_BIN).toFile();
        repo_bin = new File(repoSapforHome, "Sapfor_F");
        repo_out = new File(repoSapforHome, Constants.out_file);
        repo_err = new File(repoSapforHome, Constants.err_file);
    }
    @Override
    protected ServerCode getActivePackagesCode() {
        return ServerCode.GetFirstActiveSapforPackages;
    }
    @Override
    protected ServerCode getCheckIfNeedsKillCode() {
        return ServerCode.SapforPackageNeedsKill;
    }
    @Override
    protected TasksPackageState getStateAfterStart() {
        return TasksPackageState.RunningExecution;
    }
    @Override
    protected void InitSessionCredentials() {
        workspace = testingPackage.getLocalWorkspace();
    }
    @Override
    protected void TestsSynchronize() throws Exception {
        testingPackage.readJson();
        //--
        for (SapforTestingSet_json set_json : testingPackage.package_json.testingSets) {
            File setWorkspace = new File(workspace, String.valueOf(set_json.id));
            FileUtils.forceMkdir(setWorkspace);
            //копирование тестов по конфигурациям.
            for (SapforConfiguration_json configuration_json : set_json.configurations) {
                //--
                File configurationWorkspace = new File(setWorkspace, String.valueOf(configuration_json.id));
                FileUtils.forceMkdir(configurationWorkspace);
                //--->>>
                for (SapforTest_json test_json : set_json.tests) {
                    File test_root = new File(configurationWorkspace, test_json.description);
                    Utils.CheckAndCleanDirectory(test_root);
                    FileUtils.copyDirectory(new File(Global.TestsDirectory, String.valueOf(test_json.id)), test_root);
                }
            }
        }
    }
    @Override
    protected void PackageWorkspaceCreation() throws Exception {
        //копирование визуализатора
        File visualiser = new File(workspace, "VisualSapfor.jar");
        FileUtils.copyFile(new File(Global.Home, "TestingSystem.jar"), visualiser);
        //создание настроек
        GlobalProperties properties = new GlobalProperties(Global.properties);
        properties.Mode = Current.Mode.Package;
        Utils.jsonToFile(properties, new File(workspace, "properties"));
        //подготовка пакетного режима. Запустит его уже очередь.
        Utils.createScript(workspace, workspace, "start", "java -jar VisualSapfor.jar");
    }
    @Override
    protected void PackageStart() throws Exception {
        File script = new File(workspace, "start");
        ProcessBuilder procBuilder = new ProcessBuilder(script.getAbsolutePath());
        procBuilder.directory(workspace);
        procBuilder.start();
        //--->>
        File started = new File(workspace, Constants.STARTED);
        while (!started.exists()) {
            Print("waiting for package start...");
            Utils.sleep(1000);
        }
        File pid = new File(workspace, "PID");
        testingPackage.PID = FileUtils.readFileToString(pid, Charset.defaultCharset());
    }
    @Override
    protected boolean CheckNextState() throws Exception {
        boolean progress_changed = false;
        boolean state_changed = false;
        //--
        File workspace = testingPackage.getLocalWorkspace();
        //--
        File progress = new File(workspace, "progress");
        if (progress.exists()) {
            String s = FileUtils.readFileToString(progress);
            int current_progress = Integer.parseInt(s);
            if (current_progress != testingPackage.progress) {
                Print("progress changed: " + current_progress);
                testingPackage.progress = current_progress;
                progress_changed = true;
            }
        }
        //--
        File done = new File(workspace, Constants.DONE);
        File aborted = new File(workspace, Constants.ABORTED);
        if (done.exists()) {
            testingPackage.state = TasksPackageState.Analysis;
            state_changed = true;
        } else if (aborted.exists()) {
            testingPackage.state = TasksPackageState.Aborted;
            state_changed = true;
        }
        return progress_changed || state_changed;
    }
    @Override
    protected void DownloadResults() throws Exception {
        //не требуется.
    }
    @Override
    protected void AnalyseResults() throws Exception {
        //не требуется.
        testingPackage.progress = 100;
        testingPackage.readJson();
        UpdatePackageState(testingPackage.package_json.getState());
    }
    @Override
    protected void Kill() throws Exception {
        File workspace = testingPackage.getLocalWorkspace();
        //----
        File interrupt_file = new File(workspace, Constants.INTERRUPT);
        //----
        FileUtils.writeStringToFile(interrupt_file, new Date().toString());
        File aborted_file = new File(workspace, Constants.ABORTED);
        do {
            Print("waiting for interrupt...");
            Thread.sleep(1000);
        } while (!aborted_file.exists());
        Print("coup de grace..");
        String kill_command = "killall -SIGKILL " + testingPackage.PID;
        Print(kill_command);
        Process killer = Runtime.getRuntime().exec(kill_command);
        killer.waitFor();
        Print("done!");
    }
    //--
    @Override
    public void perform() throws Exception {
        checkServerSapforsForCompilation();
        super.perform();
    }
    //--------------------
    public void getServerSapforForCompilation() throws Exception {
        sapfor = (ServerSapfor) ServerCommand(ServerCode.GetSapforForCompilation);
    }
    void UpdateSapforState(ServerSapforState state_in) throws Exception {
        sapfor.state = state_in;
        ServerCommand(ServerCode.EditObject, sapfor);
        if (!sapfor.state.isActive()){

        }
    }
    void SyncronizeRepository() throws Exception {
        UpdateSapforState(ServerSapforState.DVMRepositorySynchronization);
        Utils.startScript(repo, repo, "dvm_checkout",
                "svn checkout " +
                        Constants.REPOSITORY_AUTHENTICATION +
                        " " + Constants.DVM_REPOSITORY + " 1>dvm_out.txt 2>dvm_err.txt\n").waitFor();
        UpdateSapforState(ServerSapforState.SAPFORRepositorySynchronization);
        Utils.startScript(repo, repo, "spf_checkout",
                "svn checkout " +
                        Constants.REPOSITORY_AUTHENTICATION +
                        " " + Constants.SAPFOR_REPOSITORY + " 1>spf_out.txt 2>spf_err.txt\n").waitFor();
    }
    void CompileSapfor() throws Exception {
        UpdateSapforState(ServerSapforState.Compilation);
        //-
        if (repo_bin.exists())
            FileUtils.forceDelete(repo_bin);
        if (repo_out.exists())
            FileUtils.forceDelete(repo_out);
        if (repo_err.exists())
            FileUtils.forceDelete(repo_err);
        //--
        Utils.startScript(repoSapforHome, repoSapforHome, "build_sapfor",
                "cmake ../ 1>" +
                        Constants.out_file +
                        " 2>" +
                        Constants.err_file +
                        "\nmake -j 14 1>>" +
                        Constants.out_file +
                        " 2>>" +
                        Constants.err_file +
                        "\n").waitFor();
    }
    //--------------------
    public void checkServerSapforsForCompilation() throws Exception {
        sapfor = null;
        getServerSapforForCompilation();
        if (sapfor != null) {
            //---
            max_version = Constants.Nan;
            current_version = Constants.Nan;
            //--
            SyncronizeRepository();
            max_version = (int) ServerCommand(ServerCode.GetMaxSapforVersion);
            current_version = Sapfor.readVersionFromCode(Paths.get(repo.getAbsolutePath(), "/sapfor/experts/Sapfor_2017/_src/Utils/version.h").toFile());
            if (current_version==max_version){
                ServerCommand(ServerCode.DeleteObjectByPK, new Pair(ServerSapfor.class,sapfor.id));
                return;
            }
            //-
            File sapforHome = new File(Global.SapforsDirectory, Utils.getDateName("sapfor"));
            //--
            sapfor.home_path = sapforHome.getAbsolutePath();
            sapfor.languageName = LanguageName.fortran;
            //--
            File sapforBin = new File(sapforHome, "Sapfor_F");
            File sapforOut = new File(sapforHome, Constants.out_file);
            File sapforErr = new File(sapforHome, Constants.err_file);
            //-
            CompileSapfor();
            sapforHome.mkdir();
            //--
            if (repo_out.exists())
                FileUtils.copyFile(repo_out, sapforOut);
            if (repo_err.exists())
                FileUtils.copyFile(repo_err, sapforErr);
            if (repo_bin.exists()) {
                FileUtils.copyFile(repo_bin, sapforBin);
                sapforBin.setExecutable(true, false);
                //--
                sapfor.version= String.valueOf(current_version);
                sapfor.call_command = sapforBin.getAbsolutePath();
                sapfor.buildDate = new Date().getTime();
                //--
                UpdateSapforState(ServerSapforState.Done);
                EmailSapforAssembly(current_version, true, sapforOut, sapforErr);
            } else {
                UpdateSapforState(ServerSapforState.DoneWithErrors);
                EmailSapforAssembly(current_version, false, sapforOut, sapforErr);
            }
        }
    }
    void EmailSapforAssembly(int version, boolean done, File out, File err) throws Exception {
        String version_s = (version == Constants.Nan) ? "?" : String.valueOf(version);
        String status = done ? "Успешно" : "С ошибками";
        //-
        EmailMessage message = new EmailMessage(
                "Выполнена сборка системы SAPFOR",
                "Версия: " + version_s + "\n" + "Статус: " + status,
                new Vector<>()
        );
        //-
        ServerCommand(ServerCode.Email, "", message);
    }
}