651 lines
30 KiB
Java
651 lines
30 KiB
Java
package TestingSystem.Common;
|
||
import Common.Constants;
|
||
import Common.Database.DBObject;
|
||
import Common.Global;
|
||
import Common.Utils.Utils;
|
||
import GlobalData.Account.Account;
|
||
import ProjectData.LanguageName;
|
||
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.MachineProcess.MachineProcess;
|
||
import TestingSystem.Common.MachineProcess.MachineProcessSet;
|
||
import TestingSystem.Common.Test.Test;
|
||
import TestingSystem.Common.Test.TestType;
|
||
import TestingSystem.Common.TestingPackageToKill.TestingPackageToKill;
|
||
import TestingSystem.DVM.DVMPackage.DVMPackage;
|
||
import TestingSystem.DVM.DVMPackage.DVMPackage_json;
|
||
import TestingSystem.DVM.DVMTestingChecker;
|
||
import TestingSystem.SAPFOR.Json.SapforPackage_json;
|
||
import TestingSystem.SAPFOR.SapforConfiguration.SapforConfiguration;
|
||
import TestingSystem.SAPFOR.SapforConfigurationCommand.SapforConfigurationCommand;
|
||
import TestingSystem.SAPFOR.SapforPackage.SapforPackage;
|
||
import TestingSystem.SAPFOR.SapforTestingPlanner;
|
||
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.nio.file.Paths;
|
||
import java.util.*;
|
||
public class TestingServer extends RepositoryServer<TestsDatabase> {
|
||
public String name = "?";
|
||
public static MachineProcessSet machinesProcesses = new MachineProcessSet();
|
||
@Override
|
||
public void afterPublishAction(DBObject object) throws Exception {
|
||
if (object instanceof Test) {
|
||
Test test = (Test) object;
|
||
if (!test.unpackProjectOnServer()) {
|
||
db.Delete(test);
|
||
throw new RepositoryRefuseException(
|
||
"Не удалось прикрепить проект к тесту с id " + test.id
|
||
+ "\nТест будет удален"
|
||
);
|
||
}
|
||
} else if (object instanceof DVMPackage) {
|
||
DVMPackage dvmPackage = (DVMPackage) object;
|
||
//--
|
||
Utils.CheckAndCleanDirectory(dvmPackage.getLocalWorkspace());
|
||
//--
|
||
dvmPackage.saveJson();
|
||
dvmPackage.package_json = null; // объект больше не нужен.
|
||
//--
|
||
} else if (object instanceof SapforPackage) {
|
||
((SapforPackage) object).init();
|
||
}
|
||
}
|
||
@Override
|
||
public void afterDeleteAction(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)
|
||
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 SapforConfiguration) {
|
||
SapforConfiguration sapforConfiguration = (SapforConfiguration) object;
|
||
Vector<SapforConfigurationCommand> commands = new Vector<>();
|
||
for (SapforConfigurationCommand command : db.sapforConfigurationCommands.Data.values()) {
|
||
if (command.sapforconfiguration_id == sapforConfiguration.id)
|
||
commands.add(command);
|
||
}
|
||
for (SapforConfigurationCommand command : commands) {
|
||
db.Delete(command);
|
||
}
|
||
} else if (object instanceof DVMPackage) {
|
||
DVMPackage dvmPackage = (DVMPackage) object;
|
||
File workspace = dvmPackage.getLocalWorkspace();
|
||
Utils.forceDeleteWithCheck(workspace);
|
||
} else if (object instanceof SapforPackage) {
|
||
SapforPackage sapforPackage = (SapforPackage) object;
|
||
File workspace = sapforPackage.getLocalWorkspace();
|
||
Utils.forceDeleteWithCheck(workspace);
|
||
}
|
||
}
|
||
//-->>>
|
||
public TestingServer() {
|
||
super(TestsDatabase.class);
|
||
name = Utils.getDateName("testingServer");
|
||
System.out.println("ServerName=" + Utils.Brackets(name));
|
||
}
|
||
//основа
|
||
@Override
|
||
public int getPort() {
|
||
return Global.properties.TestingServerPort;
|
||
}
|
||
//---
|
||
@Override
|
||
protected void startAdditionalThreads() {
|
||
testingThread.start();
|
||
}
|
||
DVMTestingChecker dvmTestingChecker = new DVMTestingChecker();
|
||
SapforTestingPlanner sapforTestingPlanner = new SapforTestingPlanner();
|
||
//--
|
||
protected Thread testingThread = new Thread(() -> {
|
||
while (true) {
|
||
dvmTestingChecker.Perform();
|
||
sapforTestingPlanner.Perform();
|
||
Utils.sleep(5000);
|
||
}
|
||
});
|
||
//------>>>
|
||
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.ActualizePackages).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 {
|
||
Test test;
|
||
int test_id;
|
||
switch (code) {
|
||
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 ReceiveTestsDatabase:
|
||
Print("Получить базу данных тестов");
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = Utils.packFile(db.getFile());
|
||
break;
|
||
//---
|
||
case RefreshDVMTests:
|
||
Print("Синхронизировать репозиторий тестов ");
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
RefreshDVMTests((Account) request.object, Integer.parseInt(request.arg));
|
||
break;
|
||
case DVMPackageNeedsKill:
|
||
Print("Проверить нуждается ли пакет DVM в убийстве");
|
||
DVMPackageNeedsKill();
|
||
break;
|
||
case UpdateActiveDVMPackages:
|
||
Print("Получить данные по пакетам DVM");
|
||
UpdateActiveDVMPackages();
|
||
break;
|
||
case GetFirstActiveSapforPackages:
|
||
Print("Получить первый активный пакет задач SAPFOR");
|
||
GetFirstActiveSapforPackages();
|
||
break;
|
||
case SapforPackageNeedsKill:
|
||
Print("Проверить нуждает ли пакет SAPFOR в убийстве");
|
||
SapforPackageNeedsKill();
|
||
break;
|
||
case UpdateActiveSapforPackages:
|
||
Print("Получить данные по пакетам Sapfor");
|
||
UpdateActiveSapforPackages();
|
||
break;
|
||
case DownloadDVMPackage:
|
||
Print("Загрузить пакет DVM");
|
||
DownloadDVMPackage();
|
||
break;
|
||
case DownloadDVMPackages:
|
||
Print("Загрузить пакеты DVM");
|
||
DownloadDVMPackages();
|
||
break;
|
||
case DownloadSapforPackage:
|
||
Print("Загрузить пакет SAPFOR");
|
||
DownloadSapforPackage();
|
||
break;
|
||
case InstallServerSapfor:
|
||
Print("Установить текущую версию SAPFOR для тестирования");
|
||
InstallServerSapfor();
|
||
break;
|
||
case ReplaceTestCode:
|
||
Print("Заменить код теста");
|
||
ReplaceTestCode();
|
||
break;
|
||
case ReplaceTestsCodes:
|
||
Print("Заменить код тестов");
|
||
ReplaceTestsCodes();
|
||
break;
|
||
case GetSapforPackagesJson:
|
||
Print("Получить информацию о задачах пакетов SAPFOR");
|
||
GetSapforPackagesJson();
|
||
break;
|
||
case GetDVMPackagesJson:
|
||
Print("Получить информацию о задачах пакетов DVM");
|
||
GetDVMPackagesJson();
|
||
break;
|
||
case GetFirstActiveDVMPackageForMachineURL:
|
||
Print("Получить первый активный пакет задач DVM на машине с адресом");
|
||
GetFirstActiveDVMPackageForMachineURL();
|
||
break;
|
||
case GetServerName:
|
||
Print("Получить имя сервера");
|
||
GetServerName();
|
||
break;
|
||
case StartNecessaryMachines:
|
||
Print("Проверка процессов машин");
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
StartNecessaryMachines();
|
||
break;
|
||
default:
|
||
throw new RepositoryRefuseException("Неподдерживаемый код: " + code);
|
||
}
|
||
}
|
||
//->>
|
||
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<>();
|
||
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)
|
||
db.RefreshGroup(account, sapfor, p);
|
||
}
|
||
private void GetFirstActiveSapforPackages() throws Exception {
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = db.getFirstActiveSapforPackagesCopies();
|
||
}
|
||
//---
|
||
void UpdateActiveDVMPackages() throws Exception {
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
Vector<Pair<Integer, Long>> keys_pairs = (Vector<Pair<Integer, Long>>) request.object;
|
||
Vector<DVMPackage> res = new Vector<>();
|
||
//--
|
||
for (Pair<Integer, Long> p : keys_pairs) {
|
||
if (db.dvmPackages.containsKey(p.getKey())) {
|
||
DVMPackage actual = db.dvmPackages.get(p.getKey());
|
||
if (actual.ChangeDate != p.getValue())
|
||
res.add(new DVMPackage(actual));
|
||
}
|
||
}
|
||
response.object = res;
|
||
}
|
||
private void UpdateActiveSapforPackages() {
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
Vector<Pair<Integer, Long>> keys_pairs = (Vector<Pair<Integer, Long>>) request.object;
|
||
Vector<SapforPackage> res = new Vector<>();
|
||
//--
|
||
for (Pair<Integer, Long> p : keys_pairs) {
|
||
if (db.sapforPackages.containsKey(p.getKey())) {
|
||
SapforPackage actual = db.sapforPackages.get(p.getKey());
|
||
if (actual.ChangeDate != p.getValue())
|
||
res.add(new SapforPackage(actual));
|
||
}
|
||
}
|
||
response.object = res;
|
||
}
|
||
private void DVMPackageNeedsKill() {
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = Constants.Nan;
|
||
int packageId = (int) request.object;
|
||
for (TestingPackageToKill packageToKill : db.testingPackagesToKill.Data.values()) {
|
||
if ((packageToKill.packageId == packageId) && (packageToKill.type == 0)) {
|
||
response.object = packageToKill.id;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
private void SapforPackageNeedsKill() throws Exception {
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = Constants.Nan;
|
||
int packageId = (int) request.object;
|
||
for (TestingPackageToKill packageToKill : db.testingPackagesToKill.Data.values()) {
|
||
if ((packageToKill.packageId == packageId) && (packageToKill.type == 1)) {
|
||
response.object = packageToKill.id;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
private void DownloadDVMPackage() throws Exception {
|
||
int dvmPackage_id = (int) request.object;
|
||
if (!db.dvmPackages.containsKey(dvmPackage_id))
|
||
throw new RepositoryRefuseException("Не найдено пакета тестирования DVM с ключом " + dvmPackage_id);
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
DVMPackage dvmPackage = db.dvmPackages.get(dvmPackage_id);
|
||
File workspace = dvmPackage.getLocalWorkspace();
|
||
File results_zip = new File(workspace, "results.zip");
|
||
File package_json = dvmPackage.getJsonFile();
|
||
response.object = new Pair(Utils.packFile(results_zip), Utils.packFile(package_json));
|
||
}
|
||
private void DownloadDVMPackages() throws Exception {
|
||
Vector<Integer> ids = (Vector<Integer>) request.object;
|
||
Vector<Pair<Integer, Pair<byte[], byte[]>>> res = new Vector<>();
|
||
for (int dvmPackage_id : ids) {
|
||
if (!db.dvmPackages.containsKey(dvmPackage_id))
|
||
throw new RepositoryRefuseException("Не найдено пакета тестирования DVM с ключом " + dvmPackage_id);
|
||
DVMPackage dvmPackage = db.dvmPackages.get(dvmPackage_id);
|
||
File workspace = dvmPackage.getLocalWorkspace();
|
||
File results_zip = new File(workspace, "results.zip");
|
||
File package_json = dvmPackage.getJsonFile();
|
||
res.add(new Pair<>(dvmPackage_id, new Pair(Utils.packFile(results_zip), Utils.packFile(package_json))));
|
||
}
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = res;
|
||
}
|
||
private void DownloadSapforPackage() throws Exception {
|
||
int sapforPackage_id = (int) request.object;
|
||
if (!db.sapforPackages.containsKey(sapforPackage_id))
|
||
throw new RepositoryRefuseException("Не найдено пакета тестирования SAPFOR с ключом " + sapforPackage_id);
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
SapforPackage sapforPackage = db.sapforPackages.get(sapforPackage_id);
|
||
File workspace = sapforPackage.getLocalWorkspace();
|
||
File results_zip = Utils.getTempFileName("results");
|
||
ZipFolderPass zipFolderPass = new ZipFolderPass();
|
||
zipFolderPass.Do(workspace.getAbsolutePath(), results_zip.getAbsolutePath());
|
||
if (results_zip.exists())
|
||
response.object = Utils.packFile(results_zip);
|
||
else
|
||
throw new RepositoryRefuseException("Не удалось заархивировать пакет тестирования SAPFOR с ключом " + sapforPackage_id);
|
||
}
|
||
private void InstallServerSapfor() throws Exception {
|
||
int max_version = Constants.Nan;
|
||
int current_version = Constants.Nan;
|
||
//--
|
||
for (ServerSapfor sapfor : db.serverSapfors.Data.values()) {
|
||
int version = -1;
|
||
try {
|
||
version = Integer.parseInt(sapfor.version);
|
||
} catch (Exception ex) {
|
||
ex.printStackTrace();
|
||
}
|
||
if (version > max_version) max_version = version;
|
||
}
|
||
System.out.println("max Sapfor version is " + max_version);
|
||
//--
|
||
File testingSystemHome = new File(Global.Home);
|
||
File repo = new File(testingSystemHome, "Repo");
|
||
File repoSapforHome = Paths.get(repo.getAbsolutePath(), Constants.SAPFOR_REPOSITORY_BIN).toFile();
|
||
File repo_bin = new File(repoSapforHome, "Sapfor_F");
|
||
File repo_out = new File(repoSapforHome, Constants.out_file);
|
||
File repo_err = new File(repoSapforHome, Constants.err_file);
|
||
//--
|
||
System.out.println("Синхронизация ветви DVM...");
|
||
Utils.startScript(repo, repo, "dvm_checkout",
|
||
"svn checkout " +
|
||
Constants.REPOSITORY_AUTHENTICATION +
|
||
" " + Constants.DVM_REPOSITORY + " 1>dvm_out.txt 2>dvm_err.txt\n").waitFor();
|
||
System.out.println("Синхронизация ветви SAPFOR...");
|
||
Utils.startScript(repo, repo, "spf_checkout",
|
||
"svn checkout " +
|
||
Constants.REPOSITORY_AUTHENTICATION +
|
||
" " + Constants.SAPFOR_REPOSITORY + " 1>spf_out.txt 2>spf_err.txt\n").waitFor();
|
||
//--
|
||
if (repo_bin.exists())
|
||
FileUtils.forceDelete(repo_bin);
|
||
//-
|
||
File versionFile = Paths.get(repo.getAbsolutePath(), "/sapfor/experts/Sapfor_2017/_src/Utils/version.h").toFile();
|
||
if (versionFile.exists()) {
|
||
List<String> data = FileUtils.readLines(versionFile);
|
||
for (String s : data) {
|
||
if (s.startsWith("#define VERSION_SPF ")) {
|
||
String[] version_data = s.split("\"");
|
||
if (version_data.length > 0) {
|
||
String version_s = version_data[1];
|
||
//-
|
||
try {
|
||
current_version = Integer.parseInt(version_s);
|
||
} catch (Exception ex) {
|
||
ex.printStackTrace();
|
||
}
|
||
//-
|
||
if (current_version == max_version) {
|
||
throw new RepositoryRefuseException("Версия SAPFOR " + max_version + " уже собрана!");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//--
|
||
System.out.println("Сборка SAPFOR...");
|
||
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();
|
||
//--
|
||
System.out.println("DONE");
|
||
File repoSapfor = new File(repoSapforHome, "Sapfor_F");
|
||
System.out.println("Result file is " + Utils.Brackets(repoSapfor.getAbsolutePath()));
|
||
//---
|
||
File sapforsDirectory = new File(testingSystemHome, "Sapfors");
|
||
File sapforHome = new File(sapforsDirectory, Utils.getDateName("sapfor"));
|
||
sapforHome.mkdir();
|
||
File sapforOut = new File(sapforHome, Constants.out_file);
|
||
File sapforErr = new File(sapforHome, Constants.err_file);
|
||
//--
|
||
System.out.println(repoSapfor.getAbsolutePath());
|
||
System.out.println(repo_out.getAbsolutePath());
|
||
System.out.println(repo_err.getAbsolutePath());
|
||
System.out.println("====================");
|
||
//--
|
||
if (repo_out.exists())
|
||
FileUtils.copyFile(repo_out, sapforOut);
|
||
if (repo_err.exists())
|
||
FileUtils.copyFile(repo_err, sapforErr);
|
||
//--
|
||
if (repoSapfor.exists()) {
|
||
System.out.println("assembly found!");
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
//создать папку. Для того чтобы скопировать из репозитория.
|
||
File sapforBin = new File(sapforHome, "Sapfor_F");
|
||
FileUtils.copyFile(repo_bin, sapforBin);
|
||
sapforBin.setExecutable(true, false);
|
||
// //-->>>
|
||
ServerSapfor serverSapfor = new ServerSapfor();
|
||
serverSapfor.home_path = sapforHome.getAbsolutePath();
|
||
serverSapfor.call_command = sapforBin.getAbsolutePath();
|
||
serverSapfor.languageName = LanguageName.fortran;
|
||
serverSapfor.buildDate = new Date().getTime();
|
||
response.object = serverSapfor;
|
||
serverSapfor.version = String.valueOf(current_version);
|
||
//---
|
||
// EmailSapforAssembly(current_version, true);
|
||
//---
|
||
} else {
|
||
//---
|
||
EmailSapforAssembly(current_version, false);
|
||
//---
|
||
throw new RepositoryRefuseException("Бинарный файл SAPFOR не найден!");
|
||
}
|
||
}
|
||
private void ReplaceTestCode() throws Exception {
|
||
Test test = (Test) request.object;
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
//---
|
||
if (!test.unpackProjectOnServer()) {
|
||
db.Delete(test);
|
||
throw new RepositoryRefuseException(
|
||
"Не удалось прикрепить проект к тесту с id " + test.id
|
||
+ "\nТест будет удален"
|
||
);
|
||
} else db.Update(test); //обновить список файлов и размерность.
|
||
}
|
||
private void ReplaceTestsCodes() throws Exception {
|
||
Vector<Test> tests = (Vector<Test>) request.object;
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
for (Test test : tests) {
|
||
if (!test.unpackProjectOnServer()) {
|
||
db.Delete(test);
|
||
throw new RepositoryRefuseException(
|
||
"Не удалось прикрепить проект к тесту с id " + test.id
|
||
+ "\nТест будет удален"
|
||
);
|
||
} else db.Update(test); //обновить список файлов и размерность.
|
||
}
|
||
}
|
||
private void EmailSapforAssembly(int version, boolean done) throws Exception {
|
||
String version_s = (version == Constants.Nan) ? "?" : String.valueOf(version);
|
||
String status = done ? "Успешно" : "С ошибками";
|
||
//-
|
||
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",
|
||
"Версия: " + version_s + "\n" + "Статус: " + status,
|
||
targets
|
||
);
|
||
//-
|
||
Email(message, out, err);
|
||
}
|
||
private void GetDVMPackagesJson() throws Exception {
|
||
Vector<Integer> packages_ids = (Vector<Integer>) request.object;
|
||
Vector<DVMPackage_json> jsons = new Vector<>();
|
||
for (int package_id : packages_ids) {
|
||
if (!db.dvmPackages.containsKey(package_id))
|
||
throw new RepositoryRefuseException("Пакета задач DVM " + Utils.Brackets(package_id) + " не существует.");
|
||
DVMPackage dvmPackage = db.dvmPackages.get(package_id);
|
||
File json = dvmPackage.getJsonFile();
|
||
if (!json.exists())
|
||
throw new RepositoryRefuseException("Не найден JSON файл для пакета задач DVM " + Utils.Brackets(package_id));
|
||
jsons.add((DVMPackage_json) Utils.jsonFromFile(json, DVMPackage_json.class));
|
||
}
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = jsons;
|
||
}
|
||
private void GetSapforPackagesJson() throws Exception {
|
||
Vector<Integer> packages_ids = (Vector<Integer>) request.object;
|
||
Vector<SapforPackage_json> jsons = new Vector<>();
|
||
for (int package_id : packages_ids) {
|
||
if (!db.sapforPackages.containsKey(package_id))
|
||
throw new RepositoryRefuseException("Пакета задач SAPFOR " + Utils.Brackets(package_id) + " не существует.");
|
||
SapforPackage sapforPackage = db.sapforPackages.get(package_id);
|
||
File json = sapforPackage.getJsonFile();
|
||
if (!json.exists())
|
||
throw new RepositoryRefuseException("Не найден JSON файл для пакета задач SAPFOR " + Utils.Brackets(package_id));
|
||
jsons.add((SapforPackage_json) Utils.jsonFromFile(json, SapforPackage_json.class));
|
||
}
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = jsons;
|
||
}
|
||
private void GetServerName() throws Exception {
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = name;
|
||
}
|
||
//--
|
||
private void GetFirstActiveDVMPackageForMachineURL() {
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = db.getFirstActiveDVMPackageCopyForMachineURL(request.arg);
|
||
}
|
||
void StartNecessaryMachines() {
|
||
try {
|
||
Vector<String> aborted = new Vector<>();
|
||
for (MachineProcess process : machinesProcesses.Data.values()) {
|
||
if (process.isAborted()) {
|
||
aborted.add(process.id);
|
||
}
|
||
}
|
||
//---
|
||
for (String key : aborted) {
|
||
machinesProcesses.Data.remove(key);
|
||
}
|
||
//---
|
||
LinkedHashMap<String, MachineProcess> processes_to_start = new LinkedHashMap<>();
|
||
//1. Получить список всех пакетов, которые активны, и взять из них машины.
|
||
for (DVMPackage dvmPackage : db.dvmPackages.Data.values()) {
|
||
if (dvmPackage.state.isActive()) {
|
||
//-
|
||
if (!machinesProcesses.hasProcessForPackage(dvmPackage)) {
|
||
MachineProcess new_process = new MachineProcess(dvmPackage);
|
||
processes_to_start.put(new_process.getUniqueKey(), new_process);
|
||
}
|
||
}
|
||
}
|
||
//запуск.
|
||
for (MachineProcess process : processes_to_start.values()) {
|
||
process.Start();
|
||
if (Utils.checkFileCreation(process.getStartedFile())) {
|
||
machinesProcesses.Data.put(process.id, process);
|
||
}
|
||
}
|
||
} catch (Exception ex) {
|
||
ex.printStackTrace();
|
||
}
|
||
}
|
||
}
|
||
|