VisualSapfor/src/TestingSystem/Common/TestingServer.java

package TestingSystem.Common;
import Common.Constants;
import Common.Database.DBObject;
import Common.Global;
import Common.Utils.Utils;
import GlobalData.Account.Account;
import GlobalData.Machine.Machine;
import GlobalData.RemoteFile.RemoteFile;
import GlobalData.Settings.SettingName;
import GlobalData.Tasks.TaskState;
import GlobalData.User.User;
import ProjectData.LanguageName;
import Repository.Component.Sapfor.Sapfor;
import Repository.EmailMessage;
import Repository.RepositoryRefuseException;
import Repository.RepositoryServer;
import Repository.Server.ServerCode;
import Repository.Server.ServerExchangeUnit_2021;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.TasksPackageToKill.TasksPackageToKill;
import TestingSystem.Common.Test.Test;
import TestingSystem.Common.Test.TestType;
import TestingSystem.DVM.Tasks.TestCompilationTask;
import TestingSystem.DVM.Tasks.TestRunTask;
import TestingSystem.DVM.Tasks.TestTask;
import TestingSystem.DVM.TasksPackage.TasksPackage;
import TestingSystem.DVM.UserConnection;
import TestingSystem.SAPFOR.SapforTask.SapforTask;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforPackageData;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import TestingSystem.SAPFOR.ServerSapfor.ServerSapfor;
import Visual_DVM_2021.Passes.All.DownloadRepository;
import Visual_DVM_2021.Passes.All.ZipFolderPass;
import Visual_DVM_2021.Passes.PassCode_2021;
import Visual_DVM_2021.Passes.Pass_2021;
import javafx.util.Pair;
import org.apache.commons.io.FileUtils;

import javax.swing.Timer;
import java.io.File;
import java.io.Serializable;
import java.nio.file.Paths;
import java.util.*;

import static Common.Constants.tests_db_name;
public class TestingServer extends RepositoryServer<TestsDatabase> {
    LinkedHashMap<String, TasksDatabase> accountsBases = new LinkedHashMap<>();
    //--------------------------------->>>
    public TestingServer() {
        super(TestsDatabase.class);
    }
    //основа
    @Override
    public int getPort() {
        return 7998;
    }
    //---
    public TasksDatabase account_db = null;
    public void SetCurrentAccountDB(String email) {
        if (accountsBases.containsKey(email)) {
            account_db = accountsBases.get(email);
        } else {
            account_db = new TasksDatabase(email.equals("?") ? "undefined" : email);
            accountsBases.put(email, account_db);
            try {
                account_db.Connect();
                account_db.CreateAllTables();
                account_db.prepareTablesStatements();
                account_db.Synchronize();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }
    @Override
    public void DeleteAction(DBObject object) throws Exception {
        if (object instanceof Test) {
            Test test = (Test) object;
            Utils.forceDeleteWithCheck(test.getArchive());
            Utils.forceDeleteWithCheck(test.getServerPath());
        } else if (object instanceof Group) {
            Group group = (Group) object;
            Vector<Test> tests = new Vector<>();
            for (Test group_test : db.tests.Data.values()) {
                if (group_test.group_id == group.id) // todo group_name -> group_id
                    tests.add(group_test);
            }
            for (Test group_test : tests) {
                db.Delete(group_test);
                Utils.forceDeleteWithCheck(group_test.getArchive());
                Utils.forceDeleteWithCheck(group_test.getServerPath());
            }
        } else if (object instanceof ServerSapfor) {
            Utils.forceDeleteWithCheck(
                    new File(
                            ((ServerSapfor) object).home_path
                    )
            );
        } else if (object instanceof SapforTasksPackage) {
            SapforTasksPackage sapforTasksPackage = (SapforTasksPackage) object;
            File workspace = new File(
                    sapforTasksPackage.workspace
            );
            System.out.println(Utils.Brackets(workspace.getAbsolutePath()));
            Utils.forceDeleteWithCheck(workspace);
            Utils.forceDeleteWithCheck(sapforTasksPackage.getArchive());
            //внешние ключи не работают
            Vector<SapforTask> tasks = new Vector<>();
            for (SapforTask task : account_db.sapforTasks.Data.values()) {
                if (task.sapfortaskspackage_id == sapforTasksPackage.id) // todo group_name -> group_id
                    tasks.add(task);
            }
            for (SapforTask task : tasks) {
                account_db.Delete(task);
            }
        }
    }
    @Override
    public boolean canDelete(DBObject object) throws Exception {
        if (object instanceof TestTask) {
            return !((TestTask) object).state.equals(TaskState.Running);
        } else
            return super.canDelete(object);
    }
    public void TestsSynchronize(String userWorkspace, Vector<Object> args) throws Exception {
        Machine machine = (Machine) args.get(0);
        User user = (User) args.get(1);
        Vector<String> test_ids = (Vector<String>) args.get(2);
        //---->>>
        UserConnection connection = new UserConnection(machine, user);
        for (String test_id : test_ids) {
            File test_src = Paths.get(Global.TestsDirectory.getAbsolutePath(), test_id).toFile();
            RemoteFile test_dst = new RemoteFile(userWorkspace + "/projects/" + test_id, true);
            connection.MKDIR(test_dst);
            connection.SynchronizeSubDirsR(test_src, test_dst);
        }
        //---->>>
        connection.Disconnect();
    }
    //--->>
    @Override
    protected void startAdditionalThreads() {
        testingThread.start();
    }
    protected TestingPlanner testingPlanner = new TestingPlanner();
    protected Thread testingThread = new Thread(() -> testingPlanner.Perform());
    //------>>>
    public static Timer checkTimer = null;
    public static void TimerOn() {
        System.out.println("timer on");
        checkTimer = new Timer(Global.properties.CheckTestingIntervalSeconds * 1000, e -> {
            Pass_2021.passes.get(PassCode_2021.SynchronizeTestsTasks).Do();
        });
        checkTimer.start();
    }
    public static void TimerOff() {
        System.out.println("timer off");
        if (checkTimer != null)
            checkTimer.stop();
    }
    public static void ResetTimer() {
        TimerOff();
        TimerOn();
    }
    @Override
    protected void Session() throws Exception {
        DBObject dbObject;
        Test test;
        int test_id;
        switch (code) {
            case EmailSapforAssembly:
                Print("Сообщить о сборке SAPFOR для пользователя " + request.arg);
                Vector<String> assembly_info = (Vector<String>) request.object;
                File out = Paths.get(Global.RepoDirectory.getAbsolutePath(), Constants.SAPFOR_REPOSITORY_BIN, Constants.out_file).toFile();
                File err = Paths.get(Global.RepoDirectory.getAbsolutePath(), Constants.SAPFOR_REPOSITORY_BIN, Constants.err_file).toFile();
                Vector<String> targets = new Vector<>(Arrays.asList(Global.admins_mails));
                EmailMessage message = new EmailMessage(
                        "Выполнена сборка системы SAPFOR",
                        "Версия: " + assembly_info.get(0) + "\n" + "Статус: " + assembly_info.get(1),
                        targets
                );
                Email(message, out, err);
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                break;
            case PublishSapforPackageTasks:
                Print("Опубликовать задачи SAPFOR для пользователя " + request.arg);
                SetCurrentAccountDB(request.arg);
                Vector<Object> tasks = (Vector<Object>) request.object;
                account_db.BeginTransaction();
                for (Object object : tasks) {
                    SapforTask task = (SapforTask) object;
                    task.id = db.IncKey(SettingName.SapforTaskMaxId);
                    account_db.Insert(task);
                }
                account_db.Commit();
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                break;
            case DownloadSapforTasksPackage:
                Print("Загрузить пакет тестов SAPFOR " + request.object + " для пользователя " + request.arg);
                SetCurrentAccountDB(request.arg);
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                //---
                if (!account_db.sapforTasksPackages.containsKey(request.object))
                    throw new RepositoryRefuseException("Не существует пакета с ключом " + Utils.Brackets(request.object));
                //--
                SapforTasksPackage sapforTasksPackage = account_db.sapforTasksPackages.get(request.object);
                //---
                //1 - архивировать пакет.
                File packageArchive = sapforTasksPackage.getArchive();
                Utils.forceDeleteWithCheck(packageArchive);
                System.out.println("src = " + Utils.Brackets(sapforTasksPackage.workspace));
                System.out.println("dst=" + Utils.Brackets(packageArchive.getAbsolutePath()));
                //---
                ZipFolderPass zip = new ZipFolderPass();
                if (zip.Do(sapforTasksPackage.workspace, packageArchive.getAbsolutePath())) {
                    response.object = Utils.packFile(packageArchive);
                    Print("Архив успешно запакован");
                } else throw new RepositoryRefuseException("Не удалось запаковать архив пакета");
                //---
                break;
            case SynchronizeTests:
                //временный проход. синхронизирует тесты на заданной машине, с сервера.
                Print("Синхронизация тестов");
                TestsSynchronize(request.arg, (Vector<Object>) request.object);
                //------------->>
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                break;
            case CheckPackageToKill:
                SetCurrentAccountDB(request.arg);
                long packageId = (long) request.object;
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                boolean res_ = false;
                for (TasksPackageToKill tasksPackageToKill : account_db.packagesToKill.Data.values()) {
                    if (tasksPackageToKill.packageId == packageId) {
                        res_ = true;
                        break;
                    }
                }
                response.object = res_;
                break;
            case EditAccountObject:
                SetCurrentAccountDB(request.arg);
                DBObject new_object = (DBObject) request.object;
                Print("Редактировать объект " + new_object.getPK() + " для пользователя " + request.arg);
                account_db.UpdateWithCheck(new_object);
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                break;
            case GetAccountObjectCopyByPK:
                SetCurrentAccountDB(request.arg);
                Pair<Class, Object> p = (Pair<Class, Object>) request.object;
                Print("Получить для пользователя " + request.arg + " копию объекта класса " + p.getKey().toString() + " по ключу " + p.getValue());
                dbObject = account_db.getObjectCopyByPK(p.getKey(), p.getValue());
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                response.object = dbObject;
                break;
            case CheckAccountObjectExistense:
                SetCurrentAccountDB(request.arg);
                p = (Pair<Class, Object>) request.object;
                Print("Проверить существование объекта класса для пользователя " + request.arg + " " + p.getKey().toString() + " с ключом " + p.getValue());
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                response.object = account_db.checkObjectExistense(p.getKey(), p.getValue());
                break;
            //------------------------------------------->>
            case DownloadTest:
                Print("Отправить клиенту тест " + request.arg);
                test_id = Integer.parseInt(request.arg);
                if (db.tests.containsKey(test_id)) {
                    test = db.tests.get(test_id);
                    response = new ServerExchangeUnit_2021(ServerCode.OK, "", Utils.packFile(test.getArchive()));
                } else
                    throw new RepositoryRefuseException("Теста с именем " + request.arg + " не существует");
                break;
//-------------------------------------------------------------------------------------->>>>
            case GetAccountQueueSize:
                Print("Получить размер очереди для пользователя " + request.arg);
                SetCurrentAccountDB(request.arg);
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                response.object = (int) account_db.testCompilationTasks.Data.values().stream().filter(ctask -> ctask.state.isActive()).count()
                        + (int) account_db.testRunTasks.Data.values().stream().filter(rtask -> rtask.state.isActive()).count();
                break;
            case GetAccountObjectsCopiesByPKs:
                Print("Получить список копий объектов для пользователя " + request.arg);
                p = (Pair<Class, Object>) request.object;
                SetCurrentAccountDB(request.arg);
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                response.object = account_db.getObjectsCopies(p.getKey(), (Vector<Object>) p.getValue());
                break;
            case GetFirstActiveAccountPackage:
                Print("Получить первый активный пакет задач для пользователя " + request.arg);
                SetCurrentAccountDB(request.arg);
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                TasksPackage tasksPackage = account_db.getFirstActivePackage();
                LinkedHashMap<Long, TestCompilationTask> activeTasks = account_db.getPackageCompilationTasks(tasksPackage);
                response.object = new Pair<>(tasksPackage, activeTasks);
                break;
            case GetFirstActiveSapforTasksPackage:
                Print("Получить первый активный сценарий задач SAPFOR" + request.arg);
                SetCurrentAccountDB(request.arg);
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                response.object = account_db.getFirstActiveSapforPackage();
                break;
            case GetQueueSize:
                Print("Получить размер глобальной очереди задач");
                long date = (long) request.object;
                long res = 0;
                Vector<String> emails = new Vector<>();
                File[] accountsBases_ = Global.DataDirectory.listFiles(pathname ->
                        pathname.isFile() &&
                                Utils.getExtension(pathname).equals("sqlite") &&
                                !Utils.getNameWithoutExtension(pathname.getName()).isEmpty() &&
                                !pathname.getName().equals(tests_db_name + ".sqlite")
                );
                if (accountsBases_ != null) {
                    for (File accountBase : accountsBases_) {
                        String fileName = accountBase.getName();
                        String account_email = accountBase.getName().substring(0, fileName.lastIndexOf('_'));
                        emails.add(account_email);
                    }
                    for (String email : emails) {
                        SetCurrentAccountDB(email);
                        res += account_db.getQueueSize(date);
                    }
                }
                //пройтись по всем аккаунтам, и узнать все пакеты, чья дата меньше равна дате в арге
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                response.object = res;
                break;
            case ReceiveTestsDatabase:
                Print("Получить базу данных тестов");
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                response.object = Utils.packFile(db.getFile());
                break;
            case ReceiveTestsTasksDatabase:
                Print("Получить базу данных тестовых задач пользователя " + request.arg);
                SetCurrentAccountDB(request.arg);
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                response.object = Utils.packFile(account_db.getFile());
                break;
            case DeleteAccountObjectByPK:
                Print("Удалить объект по ключу из базы пользователя " + request.arg);
                SetCurrentAccountDB(request.arg);
                Pair<Class, Object> to_delete = (Pair<Class, Object>) request.object;
                DeleteAction(account_db.DeleteByPK(to_delete.getKey(), to_delete.getValue()));
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                break;
            case GetActualSapforPackageData:
                Print("Запросить актуальные данные пакета");
                sapforTasksPackage = (SapforTasksPackage) request.object;
                SapforPackageData sapforPackageData = new SapforPackageData();
                Vector<String> notFoundLines = new Vector<>();
                //---
                String[] configurations = sapforTasksPackage.configurationsIds.split("\n");
                for (String id_s : configurations) {
                    int id = Integer.parseInt(id_s);
                    if (db.sapforConfigurations.containsKey(id)) {
                        sapforPackageData.sapforConfigurations.put(id, db.sapforConfigurations.get(id));
                    } else {
                        notFoundLines.add("конфигурация с ключом " + id_s + " не существует");
                    }
                }
                //---
                String[] tests = sapforTasksPackage.testsIds.split("\n");
                for (String id_s : tests) {
                    int id = Integer.parseInt(id_s);
                    if (db.tests.containsKey(id)) { //если есть тест есть и группа.
                        test = db.tests.get(id);
                        sapforPackageData.tests.put(id, test);
                        sapforPackageData.groups.put(test.group_id, db.groups.get(test.group_id));
                    } else {
                        notFoundLines.add("теста с ключом " + id_s + " не существует");
                    }
                }
                //--
                if (db.serverSapfors.containsKey(sapforTasksPackage.sapforId)) {
                    sapforPackageData.sapfor = db.serverSapfors.get(sapforTasksPackage.sapforId);
                } else
                    notFoundLines.add("версии SAPFOR с ключом" + sapforTasksPackage.sapforId + " не существует");
                //---
                if (!notFoundLines.isEmpty())
                    sapforPackageData.notFound = String.join("\n", notFoundLines);
                //---
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                response.object = sapforPackageData;
                break;
            //---
            case RefreshDVMTests:
                Print("Синхронизировать репозиторий тестов ");
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                RefreshDVMTests((Account) request.object, Integer.parseInt(request.arg));
                break;
            //--
            case UpdateTestTasks:
                Print("Обновить задачи на компиляцию и запуск");
                SetCurrentAccountDB(request.arg);
                UpdateTestTasks();
                response = new ServerExchangeUnit_2021(ServerCode.OK);
                break;
            default:
                throw new RepositoryRefuseException("Неподдерживаемый код: " + code);
        }
    }
    public void UpdateTestTasks() throws Exception {
        Vector<TestCompilationTask> compilationTasks = (Vector<TestCompilationTask>) request.object;
        account_db.BeginTransaction();
        for (TestCompilationTask compilationTask : compilationTasks) {
            compilationTask.ChangeDate = new Date().getTime();
            account_db.Update(compilationTask);
            for (TestRunTask runTask : compilationTask.runTasks) {
                compilationTask.ChangeDate = new Date().getTime();
                account_db.Update(runTask);
            }
        }
        account_db.Commit();
    }
    //->>
    //->>
    Pair<Group, Vector<File>> ConvertDirectoryToGroup(File src, LanguageName languageName, TestType
            testType, Account account) throws Exception {
        Group object = new Group();
        Vector<File> groupFiles = null; //транспорт.
        //->>
        object.description = src.getName();
        object.language = languageName;
        object.type = testType;
        object.sender_name = account.name;
        object.sender_address = account.email;
        //-->>
        File[] files = src.listFiles(pathname ->
                pathname.isFile()
                        && !pathname.getName().equals("settings")
                        && !pathname.getName().equals("test-analyzer.sh")
                        && Utils.getExtension(pathname).startsWith(languageName.getDVMCompile()));
        ;
        if (files != null) {
            groupFiles = new Vector<>(Arrays.asList(files));
            groupFiles.sort(Comparator.comparing(File::getName));
        }
        //->>
        return new Pair<>(object, groupFiles);
    }
    public void RefreshDVMTests(Account account, int sapfor_id) throws Exception {
        ServerSapfor sapfor = null;
        if (!db.serverSapfors.containsKey(sapfor_id))
            throw new RepositoryRefuseException("Версия SAPFOR  с ключом " + sapfor_id + " не найдена.");
        sapfor = db.serverSapfors.get(sapfor_id);
        DownloadRepository downloadRepository = new DownloadRepository();
        if (!downloadRepository.Do())
            throw new RepositoryRefuseException("Не удалось обновить репозиторий");
        //-->>
        Vector<Pair<Group, Vector<File>>> groups = new Vector<>();
        LinkedHashMap<Group, Vector<Test>> res = new LinkedHashMap<>();
        File testsSrc = Paths.get(
                Global.RepoDirectory.getAbsolutePath(),
                "dvm", "tools", "tester", "trunk", "test-suite").toFile();
        LanguageName[] supportedLanguages = new LanguageName[]{LanguageName.fortran, LanguageName.c};
        for (LanguageName languageName : supportedLanguages) {
            for (TestType testType : TestType.values()) {
                File groupsSrc = null;
                switch (testType) {
                    case Correctness:
                        String languageSrcName = null;
                        switch (languageName) {
                            case fortran:
                                languageSrcName = "Fortran";
                                break;
                            case c:
                                languageSrcName = "C";
                                break;
                        }
                        if (languageSrcName != null) {
                            groupsSrc = Paths.get(testsSrc.getAbsolutePath(), "Correctness", languageSrcName).toFile();
                            File[] groupsDirs = groupsSrc.listFiles(File::isDirectory);
                            if (groupsDirs != null) {
                                for (File groupDir : groupsDirs)
                                    groups.add(ConvertDirectoryToGroup(groupDir, languageName, testType, account));
                            }
                        }
                        break;
                    case Performance:
                        File groupDir = Paths.get(testsSrc.getAbsolutePath(), "Performance").toFile();
                        groups.add(ConvertDirectoryToGroup(groupDir, languageName, testType, account));
                        break;
                }
            }
        }
        groups.sort(Comparator.comparing(o -> o.getKey().description));
        //-теперь создать тесты.
        System.out.println("найдено " + groups.size() + " групп");
        //--
        for (Pair<Group, Vector<File>> p : groups) {
            Group group = p.getKey();
            //-
            db.Insert(group);
            Vector<Test> testsIds = new Vector<>();
            res.put(group, testsIds);
            //-
            Vector<File> files = p.getValue();
            if (!files.isEmpty()) {
                //->>
                for (File file : files) {
                    System.out.println("Создание теста " + file.getName());
                    Test test = new Test();
                    test.description = Utils.getNameWithoutExtension(file.getName()) + "_" + group.language.getDVMCompile();
                    test.sender_name = account.name;
                    test.sender_address = account.email;
                    test.group_id = group.id;
                    test.files = file.getName();
                    db.Insert(test);
                    testsIds.add(test);
                    //->>
                    File testDirectory = new File(Global.TestsDirectory, String.valueOf(test.id));
                    Utils.CheckAndCleanDirectory(testDirectory);
                    File testFile = Paths.get(testDirectory.getAbsolutePath(), file.getName()).toFile();
                    FileUtils.copyFile(file, testFile);
                    //----
                    //архивация.
                    File archive = test.getArchive();
                    ZipFolderPass zip = new ZipFolderPass();
                    zip.Do(testDirectory.getAbsolutePath(), archive.getAbsolutePath());
                    //---
                    //Определение размерности
                    switch (group.language) {
                        case fortran:
                            // временная папка для анализа. чтобы не засорять нормальную.
                            File tempProject = Utils.getTempFileName("test");
                            FileUtils.forceMkdir(tempProject);
                            FileUtils.copyDirectory(testDirectory, tempProject);
                            //--
                            if (Sapfor.getMinMaxDim(Sapfor.getTempCopy(new File(sapfor.call_command)), tempProject, test)) {
                                db.Update(test);
                            } else
                                throw new RepositoryRefuseException("Не удалось определить размерность теста " + Utils.Brackets(test.description));
                            break;
                        case c:
                            test.max_dim = Utils.getCTestMaxDim(testFile);
                            db.Update(test);
                            break;
                    }
                }
            }
        }
    }
    //-------------------------------------------------------------------------------------->>>
    @Override
    protected Serializable publishObject(DBObject object) throws Exception {
        if (request.arg == null) return super.publishObject(object);
        else {
            SetCurrentAccountDB(request.arg);
            return (Serializable) account_db.InsertS(object).getPK();
        }
    }
    @Override
    public void beforePublishAction(DBObject object) throws Exception {
        if (object instanceof TasksPackage) {
            TasksPackage tasksPackage = (TasksPackage) object;
            tasksPackage.id = db.IncKey(SettingName.DVMPackageMaxId);
        } else if (object instanceof SapforTasksPackage) {
            SapforTasksPackage sapforTasksPackage = (SapforTasksPackage) object;
            sapforTasksPackage.id = db.IncKey(SettingName.SAPFORPackageId);
        }
    }
    @Override
    public void afterPublishAction(DBObject object) throws Exception {
        if (object instanceof TasksPackage) {
            //объект уже вставлен.
            TasksPackage tasksPackage = (TasksPackage) object;
            //-
            for (int group_id : tasksPackage.sorted_tasks.keySet()) {
                if (db.groups.containsKey(group_id)) {
                    Group group = db.groups.get(group_id);
                    LinkedHashMap<Integer, Vector<TestCompilationTask>> group_tasks = tasksPackage.sorted_tasks.get((group_id));
                    for (int test_id : group_tasks.keySet()) {
                        if (db.tests.containsKey(test_id)) {
                            Test test = db.tests.get(test_id);
                            //---
                            for (TestCompilationTask task : group_tasks.get(test_id)) {
                                Print("принять задачу на компиляцию " + group_id + ":" + test_id + ":" + task.flags);
                                //Теперь эту задачу надо поставить в очередь. и вернуть пользователю, уже с id
                                task.state = TaskState.Waiting;
                                task.id = db.IncKey(SettingName.TaskMaxId);
                                task.taskspackage_id = tasksPackage.id;
                                task.makefile_text = group.GenerateMakefile(test, tasksPackage.dvm_drv, task.flags);
                                task.test_home = tasksPackage.user_workspace + "/projects/" + test_id;
                                //-->>
                                task.remote_workspace =
                                        new RemoteFile(
                                                tasksPackage.user_workspace + "/tests/" + tasksPackage.id,
                                                String.valueOf(task.id), true).full_name;
                                account_db.Insert(task);
                                if (task.runTasks != null) {
                                    for (TestRunTask rt : task.runTasks) {
                                        rt.id = db.IncKey(SettingName.TaskMaxId);
                                        rt.taskspackage_id = tasksPackage.id;
                                        rt.testcompilationtask_id = task.id;
                                        rt.remote_workspace =
                                                new RemoteFile(
                                                        tasksPackage.user_workspace + "/tests/" + tasksPackage.id,
                                                        String.valueOf(rt.id), true).full_name;
                                        rt.binary_name = "spf_" + rt.id + "_" + rt.matrix.replace(" ", "_");
                                        account_db.Insert(rt);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        } else if (object instanceof Test) {
            Test test = (Test) object;
            if (!test.unpackProjectOnServer()) {
                db.Delete(test);
                throw new RepositoryRefuseException(
                        "Не удалось прикрепить проект к тесту с id " + test.id
                                + "\nТест будет удален"
                );
            }
        }
    }
}