620 lines
32 KiB
Java
620 lines
32 KiB
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Тест будет удален"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|