M/VisualSapfor
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

промежуточный. выкинул старые объекты и функционал. Осталось восстановить эксель, и отображение пакетов Сапфор

Browse Source
This commit is contained in:
02090095
2023-12-16 16:52:17 +03:00
parent 94ff786ed6
commit 0c513cec5e
57 changed files with 276 additions and 3460 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
.idea/workspace.xml generated
View File

@@ -7,14 +7,61 @@
</component>
<component name="ChangeListManager">
<list default="true" id="e42177c3-2328-4b27-8a01-35779b2beb99" name="Default Changelist" comment="">
<change afterPath="$PROJECT_DIR$/src/TestingSystem/DVM/DVMTasksSet/DVMRunTasksSet.java" afterDir="false" />
<change afterPath="$PROJECT_DIR$/src/TestingSystem/DVM/DVMTasks/DVMRunTasksBar.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Common/Current.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Common/Current.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/Common/TestingPackage/TestingPackage.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/TestingSystem/Common/TestingPackage/TestingPackage.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Common/Global.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Common/Global.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Common/UI/Menus_2023/TasksPackagesMenuBar/TasksPackagesMenuBar.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Common/UI/Menus_2023/TestRunTasksMenuBar/TestRunTasksMenuBar.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Common/UI/UI.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Common/UI/UI.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Repository/Server/ServerCode.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Repository/Server/ServerCode.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/Common/TSetting/TSetting.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/Common/TSetting/TSettingsDBTable.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/Common/TasksDatabase.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/Common/TasksPackageToKill/TasksPackageToKill.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/Common/TasksPackageToKill/TasksPackageToKillDBTable.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/Common/TestingPlanner_OLD.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/Common/TestingServer.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/TestingSystem/Common/TestingServer.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/Common/TestsDatabase.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/TestingSystem/Common/TestsDatabase.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/DVM/DVMPackage/DVMPackageDBTable.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/TestingSystem/DVM/DVMPackage/DVMPackageDBTable.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/DownloadDVMPackage.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/DownloadDVMPackage.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/DVM/DVMTasks/DVMRunTask.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/TestingSystem/DVM/DVMTasks/DVMRunTask.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/DVM/DVMTasksSet/DVMRunTasksSet.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/TestingSystem/DVM/DVMTasks/DVMRunTasksSet.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/DVM/Tasks/TestCompilationTask.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/DVM/Tasks/TestCompilationTasksDBTable.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/DVM/Tasks/TestRunTask.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/DVM/Tasks/TestRunTasksDBTable.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/DVM/Tasks/TestTask.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/DVM/TasksPackage/TasksPackage.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/DVM/TasksPackage/TasksPackageDBTable.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/DVM/TestsSupervisor_2022.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/SAPFOR/Json/SapforTasksResults_json.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/TestingSystem/SAPFOR/Json/SapforTasksResults_json.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/SAPFOR/SapforPackage/SapforPackage.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/TestingSystem/SAPFOR/SapforPackage/SapforPackage.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/SAPFOR/SapforTask/SapforTask.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/TestingSystem/SAPFOR/SapforTask/SapforTask.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/SAPFOR/SapforTask/SapforTasksDBTable.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/SAPFOR/SapforTasksPackage/SapforPackageData.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/SAPFOR/SapforTasksPackage/SapforTasksPackage.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/SAPFOR/SapforTasksPackage/SapforTasksPackagesDBTable.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/TestingSystem/SAPFOR/SapforTasksPackageSupervisor/SapforTasksPackageSupervisor.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/AbortDVMPackage.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/AbortDVMPackage.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/AbortSapforTaskPackage.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/AbortTaskPackage.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/AddDVMPackage.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/AddDVMPackage.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/DeleteSapforTasksPackage.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/DeleteTasksPackage.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/DownloadSapforTasksPackage.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/DownloadTaskTest.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/DownloadTaskTest.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/ExportTasksPackageToExcel.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/ExportTasksPackageToExcel.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/GetTestsQueueSize.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/StartSapforTests.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/StartTests.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/SynchronizeTestsTasks.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/All/UnpackSapforTasksPackage.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/PassCode_2021.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/PassCode_2021.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/Server/DeleteServerAccountObject.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/Passes/Server/PublishServerAccountObject.java" beforeDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/UI/Interface/TestingWindow.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Visual_DVM_2021/UI/Interface/TestingWindow.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/UI/Main/SapforPackagesComparisonForm.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Visual_DVM_2021/UI/Main/SapforPackagesComparisonForm.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/UI/Main/TestRunTasksComparisonForm.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Visual_DVM_2021/UI/Main/DVMRunTasksComparisonForm.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/UI/Main/TestingForm.form" beforeDir="false" afterPath="$PROJECT_DIR$/src/Visual_DVM_2021/UI/Main/TestingForm.form" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/Visual_DVM_2021/UI/Main/TestingForm.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/Visual_DVM_2021/UI/Main/TestingForm.java" afterDir="false" />
</list>

54
src/Common/Current.java
View File

@@ -20,9 +20,7 @@ import Repository.BugReport.BugReport;
import Repository.Subscribes.Subscriber;
import TestingSystem.Common.Test.Test;
import TestingSystem.DVM.Configuration.Configuration;
import TestingSystem.DVM.Tasks.TestCompilationTask;
import TestingSystem.DVM.Tasks.TestRunTask;
import TestingSystem.DVM.TasksPackage.TasksPackage;
import TestingSystem.DVM.DVMTasks.DVMRunTask;
import TestingSystem.SAPFOR.SapforConfiguration.SapforConfiguration;
import Visual_DVM_2021.Passes.UI.PassForm;
@@ -36,7 +34,6 @@ public enum Current {
SapforPackage,
//--
ServerSapfor,
SapforTasksPackage,
SapforEtalonVersion,//самый левый пакет
SapforVersion,
//--
@@ -99,16 +96,12 @@ public enum Current {
SelectedFunction,
//-
Credentials,
TestCompilationTask,
TestRunTask,
TasksPackage,
//-
DialogWindow,
//-
PackageVersion,
SapforConfiguration,
SapforConfigurationCommand,
SapforTask,
SapforProfile,
SapforProfileSetting,
//--
@@ -116,7 +109,6 @@ public enum Current {
SubscriberWorkspace,
DVMRunTask;
//-
//---
private static final LinkedHashMap<Current, Object> objects = new LinkedHashMap<>();
public static Mode mode;
public static boolean hasUI() {
@@ -251,18 +243,6 @@ public enum Current {
public static boolean HasVersion() {
return get(Current.Version) != null;
}
public static TestCompilationTask getTestCompilationTask() {
return (TestingSystem.DVM.Tasks.TestCompilationTask) get(Current.TestCompilationTask);
}
public static boolean HasTestCompilationTask() {
return get(Current.TestCompilationTask) != null;
}
public static boolean HasTestRunTask() {
return get(Current.TestRunTask) != null;
}
public static TestRunTask getTestRunTask() {
return (TestingSystem.DVM.Tasks.TestRunTask) get(Current.TestRunTask);
}
public static RemoteFile getComponentServerBackup() {
return (RemoteFile) get(Current.ComponentServerBackup);
}
@@ -315,12 +295,6 @@ public enum Current {
public static FuncInfo getSelectionFunction() {
return (FuncInfo) get(Current.SelectedFunction);
}
public static boolean HasTasksPackage() {
return get(Current.TasksPackage) != null;
}
public static TasksPackage getTasksPackage() {
return (TasksPackage) get(Current.TasksPackage);
}
public static boolean HasScenario() {
return get(Current.Scenario) != null;
}
@@ -333,12 +307,6 @@ public enum Current {
public static boolean HasSapforConfiguration() {
return get(Current.SapforConfiguration) != null;
}
public static boolean HasSapforTask() {
return get(Current.SapforTask) != null;
}
public static TestingSystem.SAPFOR.SapforTask.SapforTask getSapforTask() {
return (TestingSystem.SAPFOR.SapforTask.SapforTask) get(Current.SapforTask);
}
public static ProjectData.ProjectView getProjectView() {
return (ProjectData.ProjectView) get(ProjectView);
}
@@ -373,12 +341,6 @@ public enum Current {
public static GlobalData.SapforProfile.SapforProfile getSapforProfile() {
return (GlobalData.SapforProfile.SapforProfile) get(Current.SapforProfile);
}
public static boolean HasSapforTasksPackage() {
return get(Current.SapforTasksPackage) != null;
}
public static TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage getSapforTasksPackage() {
return (TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage) get(Current.SapforTasksPackage);
}
//сапфоры установленные на тестовый сервер.
public static boolean HasServerSapfor() {
return get(Current.ServerSapfor) != null;
@@ -408,8 +370,8 @@ public enum Current {
public static boolean HasDVMRunTask() {
return get(Current.DVMRunTask) != null;
}
public static Current getDVMRunTask() {
return (Current.DVMRunTask);
public static TestingSystem.DVM.DVMTasks.DVMRunTask getDVMRunTask() {
return (TestingSystem.DVM.DVMTasks.DVMRunTask) Current.get(Current.DVMRunTask);
}
//--------------------------------------------
public String getDescription() {
@@ -426,8 +388,6 @@ public enum Current {
return "тестовая версия SAPFOR";
case SubscriberWorkspace:
return "рабочее пространство пользователя";
case SapforTasksPackage:
return "пакет задач SAPFOR";
case SapforProfile:
return "Профиль SAPFOR";
case SapforProfileSetting:
@@ -440,8 +400,6 @@ public enum Current {
return "Версия компонента для восстановления с сервера";
case Subscriber:
return "Адресат";
case SapforTask:
return "Задача SAPFOR";
case SelectedFunction:
return "Выбранный узел графа процедур";
case SapforConfigurationCommand:
@@ -450,16 +408,10 @@ public enum Current {
return "Конфигурация тестирования SAPFOR";
case PackageVersion:
return "Версия пакетного режима";
case TasksPackage:
return "Пакет задач";
case Credentials:
return "Учётные данные";
case Function:
return "Функция";
case TestRunTask:
return "Задача на запуск теста";
case TestCompilationTask:
return "Задача на компиляцию теста";
case DVMParameterValue:
return "Параметр DVM системы";
case ParallelRegion:

4
src/Common/Global.java
View File

@@ -332,10 +332,6 @@ public class Global {
componentsServer.ActivateDB();
testingServer.ActivateDB();
//-- чисто чтобы создать таблицы. соединения на стороне клиента не предвидится.
testingServer.SetCurrentAccountDB(Current.getAccount().email);
//--->>>
if (db.settings.get(SettingName.AutoBugReportsLoad).toBoolean())
Pass_2021.passes.get(PassCode_2021.SynchronizeBugReports).Do();
//--

11
src/Common/UI/Menus_2023/TasksPackagesMenuBar/TasksPackagesMenuBar.java
View File

@@ -1,11 +0,0 @@
package Common.UI.Menus_2023.TasksPackagesMenuBar;
import Common.UI.Menus_2023.DataMenuBar;
import Visual_DVM_2021.Passes.PassCode_2021;
public class TasksPackagesMenuBar extends DataMenuBar {
public TasksPackagesMenuBar() {
super("пакеты задач",
PassCode_2021.ExportTasksPackageToExcel,
PassCode_2021.AbortTaskPackage,
PassCode_2021.DeleteTasksPackage);
}
}

6
src/Common/UI/UI.java
View File

@@ -17,12 +17,13 @@ import Common.UI.Menus_2023.MainMenuBar.MainWindow;
import GlobalData.Makefile.MakefilesMenuBar;
import GlobalData.Module.ModulesMenuBar;
import GlobalData.RunConfiguration.RunConfigurationsMenuBar;
import TestingSystem.DVM.DVMTasks.DVMRunTasksBar;
import TestingSystem.DVM.DVMTasks.DVMRunTasksSet;
import TestingSystem.SAPFOR.SapforConfigurationCommand.SapforConfigurationCommandsMenuBar;
import TestingSystem.SAPFOR.SapforConfiguration.SapforConfigurationsMenuBar;
import TestingSystem.SAPFOR.ServerSapfor.ServerSapforsBar;
import Repository.SubscriberWorkspace.SubscriberWorkspacesMenuBar;
import Repository.Subscribes.SubscribersMenuBar;
import Common.UI.Menus_2023.TestRunTasksMenuBar.TestRunTasksMenuBar;
import Common.UI.Menus_2023.TestingBar.TestingBar;
import TestingSystem.Common.Test.TestsMenuBar;
import GlobalData.User.UsersMenuBar;
@@ -77,7 +78,6 @@ import TestingSystem.SAPFOR.SapforConfigurationCommand.SapforConfigurationComman
import TestingSystem.SAPFOR.ServerSapfor.ServerSapforsDBTable;
import TestingSystem.DVM.Configuration.ConfigurationDBTable;
import TestingSystem.Common.Group.GroupsDBTable;
import TestingSystem.DVM.Tasks.TestRunTasksDBTable;
import TestingSystem.Common.Test.TestDBTable;
import Visual_DVM_2021.Passes.PassCode_2021;
import Visual_DVM_2021.UI.Interface.DebugWindow;
@@ -220,7 +220,7 @@ public class UI {
menuBars.put(ConfigurationDBTable.class, new ConfigurationsMenuBar());
menuBars.put(DVMPackageDBTable.class, new DVMPackagesBar());
menuBars.put(SapforPackageDBTable.class, new SapforPackagesBar());
menuBars.put(TestRunTasksDBTable.class, new TestRunTasksMenuBar());
menuBars.put(DVMRunTasksSet.class, new DVMRunTasksBar());
//--->>>
menuBars.put(MachinesDBTable.class, new MachinesMenuBar());
menuBars.put(UsersDBTable.class, new UsersMenuBar());

23
src/Repository/Server/ServerCode.java
View File

@@ -5,8 +5,6 @@ public enum ServerCode {
SendFile,
ReceiveFile,
//--
SynchronizeTests,
//-
RegisterSubscriber,
CheckSubscriberRole,
//-
@@ -26,7 +24,6 @@ public enum ServerCode {
StartTests,
//-
RefreshDVMTests, //- для админа. получение тестов из репозитория.
PublishSapforPackageTasks,
//-
EditObject,
DeleteObject, //--------------------УСТАРЕЛО. УБРАТЬ.
@@ -36,19 +33,9 @@ public enum ServerCode {
DeleteObjectsByPK,
CheckObjectExistense, //
//--
EditAccountObject,
//--
EXIT,
//--
FAIL,
GetAccountObjectCopyByPK,
CheckAccountObjectExistense,
GetAccountQueueSize,
//--
GetAccountObjectsCopiesByPKs,
GetFirstActiveAccountPackage, //с задачами!
GetQueueSize,
CheckPackageToKill,
//--
ReceiveBugReportsDatabase,
ReceiveTestsDatabase,
@@ -66,14 +53,10 @@ public enum ServerCode {
DVMConvertProject,
SetRole,
InstallSapforForTesting,
StartSapforTests,
GetFirstActiveSapforTasksPackage,
DownloadSapforTasksPackage,
Patch,
EmailSapforAssembly,
//-
DeleteObjectByPK,
DeleteAccountObjectByPK,
//-
OLD,
//-
@@ -85,9 +68,11 @@ public enum ServerCode {
UpdateTestTasks,
ActualizeSAPFORPackages,
ActualizeDVMPackages,
// PublishTestProject
GetFirstActiveDVMPackage,
DVMPackageNeedsKill, // не доделано.
UpdateActiveDVMPackages,
GetFirstActiveSapforPackage, SapforPackageNeedsKill, UpdateActiveSapforPackages, DownloadDVMPackage;
GetFirstActiveSapforPackage,
SapforPackageNeedsKill,
UpdateActiveSapforPackages,
DownloadDVMPackage;
}

35
src/TestingSystem/Common/TSetting/TSetting.java
View File

@@ -1,35 +0,0 @@
package TestingSystem.Common.TSetting;
import Common.Database.DBObject;
import GlobalData.Settings.SettingName;
import com.sun.org.glassfish.gmbal.Description;
public class TSetting extends DBObject {
@Description("PRIMARY KEY,UNIQUE")
public SettingName Name;
public long value;
@Override
public Object getPK() {
return Name;
}
public TSetting(SettingName name_in, long value_in) {
Name = name_in;
value = value_in;
}
public TSetting(SettingName name_in, boolean value_in) {
this(name_in, value_in ? 1 : 0);
}
public TSetting() {
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
TSetting t = (TSetting) src;
Name = t.Name;
value = t.value;
}
public TSetting(TSetting src) {
this.SynchronizeFields(src);
}
public boolean toBoolean(){
return value==1;
}
}

7
src/TestingSystem/Common/TSetting/TSettingsDBTable.java
View File

@@ -1,7 +0,0 @@
package TestingSystem.Common.TSetting;
import Common.Database.DBTable;
public class TSettingsDBTable extends DBTable<String, TSetting> {
public TSettingsDBTable() {
super(String.class, TSetting.class);
}
}

199
src/TestingSystem/Common/TasksDatabase.java
View File

@@ -1,199 +0,0 @@
package TestingSystem.Common;
import Common.Constants;
import Common.Database.SQLITE.SQLiteDatabase;
import Common.Global;
import TestingSystem.Common.TSetting.TSettingsDBTable;
import TestingSystem.Common.TasksPackageToKill.TasksPackageToKillDBTable;
import TestingSystem.DVM.Tasks.TestCompilationTask;
import TestingSystem.DVM.Tasks.TestCompilationTasksDBTable;
import TestingSystem.DVM.Tasks.TestRunTask;
import TestingSystem.DVM.Tasks.TestRunTasksDBTable;
import TestingSystem.DVM.TasksPackage.TasksPackage;
import TestingSystem.DVM.TasksPackage.TasksPackageDBTable;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import TestingSystem.SAPFOR.SapforTask.SapforTasksDBTable;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackagesDBTable;
import Visual_DVM_2021.Passes.PassCode_2021;
import javafx.util.Pair;
import java.io.File;
import java.nio.file.Paths;
import java.sql.PreparedStatement;
import java.util.LinkedHashMap;
import java.util.Vector;
public class TasksDatabase extends SQLiteDatabase {
public TSettingsDBTable settings;
public TasksPackageDBTable packages;
public TasksPackageToKillDBTable packagesToKill;
public TestCompilationTasksDBTable testCompilationTasks;
public TestRunTasksDBTable testRunTasks;
PreparedStatement selectPackageRunTasks = null;
//----------
public SapforTasksPackagesDBTable sapforTasksPackages;
public SapforTasksDBTable sapforTasks;
//---------
public TasksDatabase(String email) {
super(Paths.get(Global.DataDirectory.getAbsolutePath(), email + "_" + Constants.tests_db_name + ".sqlite").toFile());
}
public TasksDatabase(File file_in) {
super(file_in);
}
public void setFile(String email) {
file = Paths.get(Global.DataDirectory.getAbsolutePath(), email + "_" + Constants.tests_db_name + ".sqlite").toFile();
}
@Override
protected void initAllTables() throws Exception {
addTable(settings = new TSettingsDBTable());
addTable(packages = new TasksPackageDBTable());
addTable(testCompilationTasks = new TestCompilationTasksDBTable());
addTable(testRunTasks = new TestRunTasksDBTable());
addTable(packagesToKill = new TasksPackageToKillDBTable());
//-----------
addTable(sapforTasksPackages = new SapforTasksPackagesDBTable());
addTable(sapforTasks = new SapforTasksDBTable());
}
@Override
public PassCode_2021 getSynchronizePassCode() {
return PassCode_2021.SynchronizeTestsTasks;
}
@Override
public void prepareTablesStatements() throws Exception {
super.prepareTablesStatements();
selectPackageRunTasks = conn.prepareStatement("SELECT * FROM TestRunTask WHERE taskspackage_id = ?");
}
@Override
protected void disconnect() throws Exception {
if (selectPackageRunTasks != null) {
selectPackageRunTasks.close();
selectPackageRunTasks = null;
}
super.disconnect();
}
public LinkedHashMap<Long, TestRunTask> getPackageRunTasks(long package_id) throws Exception {
LinkedHashMap<Long, TestRunTask> res = new LinkedHashMap<>();
selectPackageRunTasks.setLong(1, package_id);
resSet = selectPackageRunTasks.executeQuery();
while (resSet.next()) {
Pair<Long, TestRunTask> record = readRecord(testRunTasks);
res.put(record.getKey(), record.getValue());
}
return res;
}
//------
public TasksPackage getFirstActivePackage() {
TasksPackage first_active = null;
TasksPackage first_queued = null;
if (!packages.Data.isEmpty()) {
for (TasksPackage p : packages.Data.values()) {
switch (p.state) {
case Done:
case Aborted:
break;
case Queued:
if (first_queued == null) first_queued = p;
break;
default:
if (first_active == null) first_active = p; //это и будет первый активный.
break;
}
}
if (first_active != null) return first_active;
if (first_queued != null) {
first_queued.state = TasksPackageState.TestsSynchronize;
try {
Update(first_queued);
} catch (Exception ex) {
ex.printStackTrace();
}
}
return first_queued;
}
return null;
}
public LinkedHashMap<Long, TestCompilationTask> getPackageCompilationTasks(TasksPackage tasksPackage) {
if (tasksPackage == null) return null;
LinkedHashMap<Long, TestCompilationTask> res = new LinkedHashMap<>();
for (TestCompilationTask srcCompilationTask : testCompilationTasks.Data.values()) {
if (srcCompilationTask.taskspackage_id==tasksPackage.id) {
TestCompilationTask dstCompilationTask = new TestCompilationTask(srcCompilationTask);
dstCompilationTask.runTasks = new Vector<>();
for (TestRunTask testRunTask : testRunTasks.Data.values())
if (testRunTask.testcompilationtask_id == srcCompilationTask.id)
dstCompilationTask.runTasks.add(new TestRunTask(testRunTask));
res.put(dstCompilationTask.id, dstCompilationTask);
}
}
return res;
}
public long getQueueSize(long date) throws Exception {
long sum = 0L;
for (TasksPackage tasksPackage : packages.Data.values()) {
if (tasksPackage.StartDate < date) {
Vector<TestRunTask> tasks = new Vector<>(getPackageRunTasks(tasksPackage.id).values());
for (TestRunTask testRunTask : tasks)
if (testRunTask.compilation_state.isActive() || testRunTask.state.isActive())
sum++;
}
}
return sum;
}
//--
/*
public Vector<TasksPackage> getActivePackages() {
Vector<TasksPackage> res = new Vector<>();
for (TasksPackage p : packages.Data.values())
if (!p.state.equals(TasksPackageState.Done))
res.add(p);
return res;
}
public Vector<SapforTasksPackage> getActiveSapforPackages() {
Vector<SapforTasksPackage> res = new Vector<>();
for (SapforTasksPackage p : sapforTasksPackages.Data.values())
if (!p.state.equals(TasksPackageState.Done))
res.add(p);
return res;
}
*/
public SapforTasksPackage getFirstActiveSapforPackage() {
SapforTasksPackage first_active = null;
SapforTasksPackage first_queued = null;
if (!sapforTasksPackages.Data.isEmpty()) {
for (SapforTasksPackage p : sapforTasksPackages.Data.values()) {
switch (p.state) {
case Done:
case Aborted:
break;
case Queued:
if (first_queued == null) first_queued = p;
break;
default:
if (first_active == null) first_active = p; //это и будет первый активный.
break;
}
}
if (first_active != null) return first_active;
if (first_queued != null) {
first_queued.state = TasksPackageState.TestsSynchronize;
try {
Update(first_queued);
} catch (Exception ex) {
ex.printStackTrace();
}
}
return first_queued;
}
return null;
}
public boolean hasActivePackages() {
for (TasksPackage tasksPackage : packages.Data.values()) {
if (tasksPackage.state.isActive())
return true;
}
for (SapforTasksPackage sapforTasksPackage : sapforTasksPackages.Data.values()) {
if (sapforTasksPackage.state.isActive())
return true;
}
return false;
}
}

8
src/TestingSystem/Common/TasksPackageToKill/TasksPackageToKill.java
View File

@@ -1,8 +0,0 @@
package TestingSystem.Common.TasksPackageToKill;
import Common.Constants;
import Common.Database.iDBObject;
import com.sun.org.glassfish.gmbal.Description;
public class TasksPackageToKill extends iDBObject {
@Description("DEFAULT -1")
public long packageId = Constants.Nan;
}

7
src/TestingSystem/Common/TasksPackageToKill/TasksPackageToKillDBTable.java
View File

@@ -1,7 +0,0 @@
package TestingSystem.Common.TasksPackageToKill;
import Common.Database.iDBTable;
public class TasksPackageToKillDBTable extends iDBTable<TasksPackageToKill> {
public TasksPackageToKillDBTable() {
super(TasksPackageToKill.class);
}
}

232
src/TestingSystem/Common/TestingPlanner_OLD.java
View File

@@ -1,232 +0,0 @@
package TestingSystem.Common;
import Common.Global;
import Common.Utils.Utils;
import GlobalData.Machine.Machine;
import GlobalData.User.User;
import Repository.EmailMessage;
import Repository.Server.ServerCode;
import Repository.Server.ServerExchangeUnit_2021;
import TestingSystem.DVM.Tasks.TestCompilationTask;
import TestingSystem.DVM.TasksPackage.TasksPackage;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import TestingSystem.DVM.TestsSupervisor_2022;
import TestingSystem.DVM.UserConnection;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import TestingSystem.SAPFOR.SapforTasksPackageSupervisor.SapforTasksPackageSupervisor;
import Visual_DVM_2021.Passes.PassException;
import Visual_DVM_2021.Passes.SSH.ConnectionPass;
import Visual_DVM_2021.Passes.Server.TestingSystemPass;
import javafx.util.Pair;
import java.io.File;
import java.io.FileWriter;
import java.io.Serializable;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Vector;
import static Common.Constants.tests_db_name;
public class TestingPlanner_OLD {
public String email;
TasksPackage tasksPackage;
TestsSupervisor_2022 supervisor;
LinkedHashMap<String, Machine> machines = new LinkedHashMap<>();
LinkedHashMap<String, User> users = new LinkedHashMap<>();
protected Machine machine = null;
protected User user = null;
public LinkedHashMap<Long, TestCompilationTask> packageTasks = new LinkedHashMap<>();
//----------
SapforTasksPackage sapforTasksPackage = null;
//----------
public void UpdatePackage() throws Exception {
tasksPackage.ChangeDate = new Date().getTime();
ServerCommand(ServerCode.EditAccountObject, tasksPackage);
//---------------
if ((tasksPackage.needsEmail == 1) &&
(tasksPackage.state.equals(TasksPackageState.PackageStart) ||
(tasksPackage.state.equals(TasksPackageState.Done)) ||
(tasksPackage.state.equals(TasksPackageState.Aborted))
)) {
EmailMessage message = new EmailMessage();
message.subject = "Состояние пакета задач " + Utils.Brackets(tasksPackage.id) + " изменилось на " + Utils.Brackets(tasksPackage.state.getDescription());
message.text = tasksPackage.summary;
message.targets.add(email);
ServerCommand(ServerCode.Email, message);
}
}
//-
public Object ServerCommand(ServerCode code_in, String arg, Serializable object_in) throws Exception {
TestingSystemPass<Object> pass = new TestingSystemPass<Object>() {
@Override
public String getDescription() {
return "";
}
@Override
protected void ServerAction() throws Exception {
Command(new ServerExchangeUnit_2021(code_in, arg, object_in));
target = response.object;
}
};
if (!pass.Do()) throw new PassException("Ошибка взаимодействия с сервером " + code_in);
return pass.target;
}
public Object ServerCommand(ServerCode code_in, Serializable object_in) throws Exception {
return ServerCommand(code_in, email, object_in);
}
Object ServerCommand(ServerCode code_in) throws Exception {
return ServerCommand(code_in, email, null);
}
//-
boolean isPrintOn() {
return true;
}
public void Print(String message) {
try {
FileWriter testLog = new FileWriter(getClass().getSimpleName() + "_Log.txt", true);
String dmessage = Utils.Brackets(new Date()) + " " + message;
if (isPrintOn())
System.out.println(dmessage);
testLog.write(dmessage + "\n");
testLog.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
boolean CheckConnection(Machine machine, User user) {
//каждый раз соединяемся по новой. из за проблем с Exists.
// к тому же, теперь задачи гоняет модуль, тут только проверка
//так что время на разрыв уже не критично.
try {
user.connection = null;
user.connection = new UserConnection(machine, user);
Print("Соединение c " + machine.getURL() + " " + user.login + " успешно установлено.");
user.connection.ShellCommand("ulimit -s unlimited"); // нужно, для запуска сишной части.
} catch (Exception ex) {
Global.Log.PrintException(ex);
user.connection = null;
Print("Не удалось установить соединение.");
}
return user.connection != null;
}
//-
public void Perform() {
Vector<String> emails = new Vector<>();
while (true) {
emails.clear();
try {
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 current_email : emails)
emailPass(current_email);
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
try {
Utils.sleep(getSleepMillis());
} catch (Exception ignored) {
}
}
}
}
protected int getSleepMillis() {
return 2000;
}
void emailPass(String email_in) {
email = email_in;
try {
// System.out.println(email+" testing planner starts...");
Pair<TasksPackage, LinkedHashMap<Long, TestCompilationTask>> p = (Pair<TasksPackage, LinkedHashMap<Long, TestCompilationTask>>) ServerCommand(ServerCode.GetFirstActiveAccountPackage);
sapforTasksPackage = (SapforTasksPackage) ServerCommand(ServerCode.GetFirstActiveSapforTasksPackage);
tasksPackage = null;
packageTasks = null;
tasksPackage = p.getKey();
packageTasks = p.getValue();
if (tasksPackage != null) {
// System.out.println("found dvm package: "+sapforTasksPackage.id);
String machine_url = tasksPackage.machine_address + ":" + tasksPackage.machine_port;
if (!machines.containsKey(machine_url))
machines.put(machine_url, new Machine(
tasksPackage.machine_name,
tasksPackage.machine_address,
tasksPackage.machine_port,
tasksPackage.machine_type));
if (!users.containsKey(tasksPackage.user_name))
users.put(tasksPackage.user_name,
new User(tasksPackage.user_name, tasksPackage.user_password, tasksPackage.user_workspace));
machine = machines.get(machine_url);
//-->>
user = users.get(tasksPackage.user_name);
if (CheckConnection(machine, user)) {
try {
supervisor = new TestsSupervisor_2022(this, user.connection, tasksPackage, new Vector<>(packageTasks.values()));
supervisor.Perform();
} catch (Exception ex) {
Print("Ошибка сеанса.");
Print(ex.getMessage());
}
finally {
if (user.connection != null) {
user.connection.Disconnect();
user.connection = null;
}
}
}
}
if (sapforTasksPackage != null) {
System.out.println("found sapfor package: " + sapforTasksPackage.id + " state = " + sapforTasksPackage.state);
try {
(new SapforTasksPackageSupervisor(this, sapforTasksPackage)).Perform();
} catch (Exception ex) {
Print("Исключение при тестировании SAPROR");
Print(ex.getMessage());
}
}
} catch (Exception ex) {
Global.Log.PrintException(ex);
}
}
public String getStarter() {
return String.join("/", user.workspace, ConnectionPass.modules, ConnectionPass.starter);
}
public String getLauncher() {
return String.join("/", user.workspace, ConnectionPass.modules, ConnectionPass.launcher);
}
public String getPlanner() {
return String.join("/", user.workspace, ConnectionPass.modules, ConnectionPass.planner);
}
//--
public void UpdateSapforPackage() throws Exception {
sapforTasksPackage.ChangeDate = new Date().getTime();
EmailMessage message = null;
ServerCommand(ServerCode.EditAccountObject, sapforTasksPackage);
if (sapforTasksPackage.needsEmail == 1) {
switch (sapforTasksPackage.state) {
case RunningExecution:
case Aborted:
case Done:
//результаты.
message = new EmailMessage();
message.subject = "Состояние пакета задач SAPFOR" + Utils.Brackets(sapforTasksPackage.id) + " изменилось на " + Utils.Brackets(sapforTasksPackage.state.getDescription());
message.text = sapforTasksPackage.summary;
break;
default:
break;
}
}
if (message != null) {
message.targets.add(email);
ServerCommand(ServerCode.Email, message);
}
}
}

430
src/TestingSystem/Common/TestingServer.java
View File

@@ -1,15 +1,9 @@
package TestingSystem.Common;
import Common.Constants;
import Common.Database.DBObject;
import Common.Database.Database;
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;
@@ -18,24 +12,14 @@ 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.Common.TestingPackageToKill.TestingPackageToKill;
import TestingSystem.DVM.DVMPackage.DVMPackage;
import TestingSystem.DVM.DVMTestingPlanner;
import TestingSystem.DVM.Tasks.TestCompilationTask;
import TestingSystem.DVM.Tasks.TestRunTask;
import TestingSystem.DVM.Tasks.TestTask;
import TestingSystem.DVM.TasksPackage.TasksPackage;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import TestingSystem.DVM.UserConnection;
import TestingSystem.SAPFOR.SapforConfiguration.SapforConfiguration;
import TestingSystem.SAPFOR.SapforConfigurationCommand.SapforConfigurationCommand;
import TestingSystem.SAPFOR.SapforPackage.SapforPackage;
import TestingSystem.SAPFOR.SapforTask.SapforTask;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforPackageData;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import TestingSystem.SAPFOR.SapforTestingPlanner;
import TestingSystem.SAPFOR.ServerSapfor.ServerSapfor;
import Visual_DVM_2021.Passes.All.DownloadRepository;
@@ -45,70 +29,17 @@ import Visual_DVM_2021.Passes.Pass_2021;
import javafx.util.Pair;
import org.apache.commons.io.FileUtils;
import javax.swing.Timer;
import javax.swing.*;
import java.io.File;
import java.nio.file.Paths;
import java.util.*;
import static Common.Constants.tests_db_name;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Vector;
public class TestingServer extends RepositoryServer<TestsDatabase> {
@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) {
if (object instanceof Test) {
Test test = (Test) object;
if (!test.unpackProjectOnServer()) {
db.Delete(test);
@@ -157,23 +88,6 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
((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);
}
} else if (object instanceof SapforConfiguration) {
SapforConfiguration sapforConfiguration = (SapforConfiguration) object;
Vector<SapforConfigurationCommand> commands = new Vector<>();
@@ -195,8 +109,6 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
}
}
//-->>>
LinkedHashMap<String, TasksDatabase> accountsBases = new LinkedHashMap<>();
//--------------------------------->>>
public TestingServer() {
super(TestsDatabase.class);
}
@@ -206,58 +118,14 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
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 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();
testingThread_2023.start();
testingThread.start();
}
protected TestingPlanner_OLD testingPlannerOLD = new TestingPlanner_OLD();
protected Thread testingThread = new Thread(() -> testingPlannerOLD.Perform());
//---
protected DVMTestingPlanner DVMTestingPlanner = new DVMTestingPlanner();
protected SapforTestingPlanner sapforTestingPlanner = new SapforTestingPlanner();
//--
protected Thread testingThread_2023 = new Thread(() -> {
protected Thread testingThread = new Thread(() -> {
while (true) {
DVMTestingPlanner.Perform();
sapforTestingPlanner.Perform();
@@ -285,7 +153,6 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
}
@Override
protected void Session() throws Exception {
DBObject dbObject;
Test test;
int test_id;
switch (code) {
@@ -303,84 +170,6 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
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);
@@ -391,143 +180,17 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
} 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;
afterDeleteAction(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;
case ActualizeDVMPackages:
Print("Получить данные по пакетам DVM");
SetCurrentAccountDB(request.arg);
response = new ServerExchangeUnit_2021(ServerCode.OK);
ActualizeDVMPackages();
break;
case ActualizeSAPFORPackages:
Print("Получить данные по пакетам SAPFOR");
SetCurrentAccountDB(request.arg);
response = new ServerExchangeUnit_2021(ServerCode.OK);
ActualizeSAPFORPackages();
break;
case GetFirstActiveDVMPackage:
Print("Получить первый активный пакет задач DVM");
GetFirstActiveDVMPackage();
@@ -560,20 +223,6 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
throw new RepositoryRefuseException("Неподдерживаемый код: " + code);
}
}
public void UpdateTestTasks() throws Exception {
Vector<TestCompilationTask> compilationTasks = (Vector<TestCompilationTask>) request.object;
account_db.BeginTransaction();
//сами задачи на компиляцию не сохраняем. незачем.
for (TestCompilationTask compilationTask : compilationTasks) {
account_db.Delete(compilationTask);
for (TestRunTask runTask : compilationTask.runTasks) {
runTask.ChangeDate = new Date().getTime();
account_db.UpdateWithCheck(runTask);
}
}
account_db.Commit();
}
//->>
//->>
Pair<Group, Vector<File>> ConvertDirectoryToGroup(File src, LanguageName languageName, TestType
testType, Account account) throws Exception {
@@ -702,69 +351,6 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
}
}
//-------------------------------------------------------------------------------------->>>
@Override
protected Database getDefaultDatabase() {
if (request.arg == null) return super.getDefaultDatabase();
SetCurrentAccountDB(request.arg);
return account_db;
}
//---------------------------------------------------------------------------------------------->>>
//устарели. убрать.
void ActualizeDVMPackages() throws Exception {
response = new ServerExchangeUnit_2021(ServerCode.OK);
Vector<Pair<Long, TasksPackageState>> keys_pairs = (Vector<Pair<Long, TasksPackageState>>) request.object;
//--
Vector<Pair<TasksPackage, Vector<TestRunTask>>> res = new Vector<>();
//--
for (Pair<Long, TasksPackageState> p : keys_pairs) {
if (account_db.packages.containsKey(p.getKey())) {
TasksPackage tasksPackage = account_db.packages.get(p.getKey());
if (!p.getValue().equals(tasksPackage.state)) {
Vector<TestRunTask> tasks = new Vector<>();
//если пакет завершен, берем задачи.
if (tasksPackage.state.equals(TasksPackageState.Done)) {
for (TestRunTask task : account_db.testRunTasks.Data.values()) {
if (task.taskspackage_id == tasksPackage.id) {
System.out.println(task.id + ":" + task.state);
tasks.add(task);
}
}
}
res.add(new Pair<>(tasksPackage, tasks));
}
}
}
response.object = res;
//--
}
//--
void ActualizeSAPFORPackages() throws Exception {
Vector<Pair<Long, TasksPackageState>> keys_pairs = (Vector<Pair<Long, TasksPackageState>>) request.object;
//--
Vector<Pair<SapforTasksPackage, Vector<SapforTask>>> res = new Vector<>();
//--
for (Pair<Long, TasksPackageState> p : keys_pairs) {
if (account_db.sapforTasksPackages.containsKey(p.getKey())) {
SapforTasksPackage tasksPackage = account_db.sapforTasksPackages.get(p.getKey());
if (!p.getValue().equals(tasksPackage.state)) {
Vector<SapforTask> tasks = new Vector<>();
//если пакет завершен, берем задачи.
if (tasksPackage.state.equals(TasksPackageState.Done)) {
for (SapforTask task : account_db.sapforTasks.Data.values()) {
if (task.sapfortaskspackage_id == tasksPackage.id) {
System.out.println(task.id + ":" + task.state);
tasks.add(task);
}
}
}
res.add(new Pair<>(tasksPackage, tasks));
}
}
}
response.object = res;
//--
}
//--
void GetFirstActiveDVMPackage() throws Exception {
response = new ServerExchangeUnit_2021(ServerCode.OK);
response.object = null;

28
src/TestingSystem/Common/TestsDatabase.java
View File

@@ -3,14 +3,12 @@ import Common.Constants;
import Common.Database.SQLITE.SQLiteDatabase;
import GlobalData.Settings.SettingName;
import TestingSystem.Common.Group.GroupsDBTable;
import TestingSystem.Common.TSetting.TSetting;
import TestingSystem.Common.TSetting.TSettingsDBTable;
import TestingSystem.Common.Test.TestDBTable;
import TestingSystem.Common.TestingPackageToKill.TestingPackagesToKillDBTable;
import TestingSystem.DVM.Configuration.ConfigurationDBTable;
import TestingSystem.DVM.DVMPackage.DVMPackage;
import TestingSystem.DVM.DVMPackage.DVMPackageDBTable;
import TestingSystem.DVM.DVMTasksSet.DVMRunTasksSet;
import TestingSystem.DVM.DVMTasks.DVMRunTasksSet;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import TestingSystem.SAPFOR.SapforConfiguration.SapforConfigurationDBTable;
import TestingSystem.SAPFOR.SapforConfigurationCommand.SapforConfigurationCommandsDBTable;
@@ -21,8 +19,6 @@ import Visual_DVM_2021.Passes.PassCode_2021;
import java.nio.file.Paths;
public class TestsDatabase extends SQLiteDatabase {
public TSettingsDBTable settings; //todo ВЫВЕСТИ
///--
public ConfigurationDBTable configurations;
public TestDBTable tests;
public GroupsDBTable groups;
@@ -48,7 +44,6 @@ public class TestsDatabase extends SQLiteDatabase {
addTable(tests = new TestDBTable());
addTable(dvmPackages = new DVMPackageDBTable());
addTable(sapforPackages = new SapforPackageDBTable());
addTable(settings = new TSettingsDBTable());
addTable(testingPackagesToKill = new TestingPackagesToKillDBTable());
//-
addTable(sapforConfigurations = new SapforConfigurationDBTable());
@@ -56,30 +51,9 @@ public class TestsDatabase extends SQLiteDatabase {
addTable(serverSapfors = new ServerSapforsDBTable());
}
@Override
public void Init() throws Exception {
if (!settings.containsKey(SettingName.DVMPackageMaxId))
Insert(new TSetting(SettingName.DVMPackageMaxId, 0));
//-
if (!settings.containsKey(SettingName.SAPFORPackageId))
Insert(new TSetting(SettingName.SAPFORPackageId, 0));
//-
if (!settings.containsKey(SettingName.TaskMaxId))
Insert(new TSetting(SettingName.TaskMaxId, 0));
//-
if (!settings.containsKey(SettingName.SapforTaskMaxId))
Insert(new TSetting(SettingName.SapforTaskMaxId, 0));
}
@Override
public PassCode_2021 getSynchronizePassCode() {
return PassCode_2021.SynchronizeTests;
}
public long IncKey(SettingName settingName) throws Exception {
TSetting setting = settings.get(settingName);
long res = setting.value;
setting.value++;
Update(setting);
return res;
}
public DVMPackage getFirstActiveDVMPackage() {
DVMPackage first_active = null;
DVMPackage first_queued = null;

3
src/TestingSystem/DVM/DVMPackage/DVMPackageDBTable.java
View File

@@ -41,13 +41,12 @@ public class DVMPackageDBTable extends iDBTable<DVMPackage> {
@Override
public void ShowCurrentObject() throws Exception {
super.ShowCurrentObject();
// Global.testingServer.db.dvmRunTasks.ShowDVMPackage(getCurrent());
UI.getMainWindow().getTestingWindow().DropTestRunTasksComparison();
}
@Override
public void ShowNoCurrentObject() throws Exception {
super.ShowNoCurrentObject();
// Global.testingServer.db.dvmRunTasks.ShowNoPackage();
Global.testingServer.db.dvmRunTasks.ShowNoPackage();
UI.getMainWindow().getTestingWindow().DropTestRunTasksComparison();
}
};

25
src/TestingSystem/DVM/DVMTasks/DVMRunTask.java
View File

@@ -1,20 +1,14 @@
package TestingSystem.DVM.DVMTasks;
import Common.Constants;
import Common.Current;
import Common.Database.DBObject;
import Common.Global;
import Common.Utils.Utils;
import GlobalData.Tasks.TaskState;
import ProjectData.LanguageName;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.Test.Test;
import TestingSystem.Common.Test.TestType;
import TestingSystem.DVM.Configuration.Configuration;
import TestingSystem.DVM.DVMPackage.DVMPackage;
import TestingSystem.DVM.Tasks.TestRunTask;
import TestingSystem.DVM.Tasks.TestTask;
import com.google.gson.annotations.Expose;
import com.sun.org.glassfish.gmbal.Description;
import java.util.Vector;
public class DVMRunTask extends DVMTask {
@@ -114,5 +108,24 @@ public class DVMRunTask extends DVMTask {
public String getUsrPar() {
return usr_par.replace("\n", ";");
}
@Override
public boolean isVisible() {
return Global.testingServer.db.dvmRunTasks.applyFilters(this);
}
public String getCompilationOutput() {
return "?";
}
public String getCompilationErrors() {
return "?";
}
public String getOutput() {
return "?";
}
public String getErrors() {
return "?";
}
public String getStatistic() {
return "?";
}
}
//--

10
src/Common/UI/Menus_2023/TestRunTasksMenuBar/TestRunTasksMenuBar.java → src/TestingSystem/DVM/DVMTasks/DVMRunTasksBar.java
View File

@@ -1,9 +1,10 @@
package Common.UI.Menus_2023.TestRunTasksMenuBar;
package TestingSystem.DVM.DVMTasks;
import Common.Database.DataSet;
import Common.UI.Menus_2023.DataMenuBar;
import Visual_DVM_2021.Passes.PassCode_2021;
import javax.swing.*;
public class TestRunTasksMenuBar extends DataMenuBar {
public class DVMRunTasksBar extends DataMenuBar {
JMenuBar filters= null;
public void DropFilters() {
if (filters != null) {
@@ -16,8 +17,7 @@ public class TestRunTasksMenuBar extends DataMenuBar {
public void addFilters(JMenu cFilterMenu, JMenu rFilterMenu) {
filters= addMenus(cFilterMenu, rFilterMenu);
}
public TestRunTasksMenuBar() {
super("задачи",
PassCode_2021.DownloadTaskTest);
public DVMRunTasksBar() {
super("задачи", PassCode_2021.DownloadTaskTest);
}
}

142
src/TestingSystem/DVM/Tasks/TestRunTasksDBTable.java → src/TestingSystem/DVM/DVMTasks/DVMRunTasksSet.java
View File

@@ -1,35 +1,35 @@
package TestingSystem.DVM.Tasks;
package TestingSystem.DVM.DVMTasks;
import Common.Current;
import Common.Database.DBTable;
import Common.Database.DataSet;
import Common.Database.TableFilter;
import Common.UI.DataSetControlForm;
import Common.UI.Menus_2023.TestRunTasksMenuBar.TestRunTasksMenuBar;
import Common.UI.Menus_2023.VisualiserMenu;
import Common.UI.UI;
import GlobalData.Tasks.TaskState;
import TestingSystem.DVM.DVMPackage.DVMPackage;
import javax.swing.*;
import java.util.Comparator;
import java.util.Vector;
import static Common.UI.Tables.TableRenderers.RendererProgress;
import static Common.UI.Tables.TableRenderers.RendererStatusEnum;
public class TestRunTasksDBTable extends DBTable<Long, TestRunTask> {
public class DVMRunTasksSet extends DataSet<Integer, DVMRunTask> {
//todo обобщить бы наличие фильтров для всех таблиц.
public Vector<TableFilter<DVMRunTask>> compilationFilters;
public Vector<TableFilter<DVMRunTask>> runFilters;
DVMPackage target;
public DVMRunTasksSet() {
super(Integer.class, DVMRunTask.class);
//todo обобщить бы наличие фильтров для всех таблиц.
public Vector<TableFilter<TestRunTask>> compilationFilters;
public Vector<TableFilter<TestRunTask>> runFilters;
public TestRunTasksDBTable() {
super(Long.class, TestRunTask.class);
//--
if (Current.hasUI()) {
compilationFilters = new Vector<>();
runFilters = new Vector<>();
//--
for (TaskState state : TaskState.values()) {
if (state.isVisible()) {
compilationFilters.add(new TableFilter<TestRunTask>(this, state.getDescription()) {
compilationFilters.add(new TableFilter<DVMRunTask>(this, state.getDescription()) {
@Override
protected boolean validate(TestRunTask object) {
protected boolean validate(DVMRunTask object) {
return object.compilation_state.equals(state);
}
});
@@ -38,9 +38,9 @@ public class TestRunTasksDBTable extends DBTable<Long, TestRunTask> {
//--
for (TaskState state : TaskState.values()) {
if (state.isVisible()) {
runFilters.add(new TableFilter<TestRunTask>(this, state.getDescription()) {
runFilters.add(new TableFilter<DVMRunTask>(this, state.getDescription()) {
@Override
protected boolean validate(TestRunTask object) {
protected boolean validate(DVMRunTask object) {
return object.state.equals(state);
}
});
@@ -49,20 +49,20 @@ public class TestRunTasksDBTable extends DBTable<Long, TestRunTask> {
}
}
public void ResetFiltersCount() {
for (TableFilter<TestRunTask> filter : compilationFilters)
for (TableFilter<DVMRunTask> filter : compilationFilters)
filter.count = 0;
for (TableFilter<TestRunTask> filter : runFilters)
for (TableFilter<DVMRunTask> filter : runFilters)
filter.count = 0;
}
public void ShowFiltersCount() {
for (TableFilter<TestRunTask> filter : compilationFilters) {
for (TableFilter<DVMRunTask> filter : compilationFilters) {
filter.ShowDescriptionAndCount();
}
for (TableFilter<TestRunTask> filter : runFilters) {
for (TableFilter<DVMRunTask> filter : runFilters) {
filter.ShowDescriptionAndCount();
}
}
public boolean applyFilters(TestRunTask object) {
public boolean applyFilters(DVMRunTask object) {
boolean compilation = false;
//возвращать сразу нельзя. иначе количество не посчитает.
for (TableFilter filter : compilationFilters) {
@@ -79,6 +79,40 @@ public class TestRunTasksDBTable extends DBTable<Long, TestRunTask> {
return compilation && run;
}
@Override
public void mountUI(JPanel content_in) {
super.mountUI(content_in);
//-
DVMRunTasksBar menuBar = (DVMRunTasksBar) UI.menuBars.get(getClass());
menuBar.DropFilters();
//----
menuBar.addFilters(
new VisualiserMenu("Компиляция", "/icons/Filter.png", true) {
{
for (TableFilter filter : compilationFilters)
add(filter.menuItem);
}
},
new VisualiserMenu("Запуск", "/icons/Filter.png", true) {
{
for (TableFilter filter : runFilters)
add(filter.menuItem);
}
}
);
}
@Override
public void ShowUI() {
ResetFiltersCount();
super.ShowUI();
ShowFiltersCount();
}
@Override
public void ShowUI(Object key) {
ResetFiltersCount();
super.ShowUI(key);
ShowFiltersCount();
}
@Override
public String getSingleDescription() {
return "задача";
}
@@ -102,28 +136,6 @@ public class TestRunTasksDBTable extends DBTable<Long, TestRunTask> {
};
}
@Override
public void mountUI(JPanel content_in) {
super.mountUI(content_in);
//-
TestRunTasksMenuBar menuBar = (TestRunTasksMenuBar) UI.menuBars.get(getClass());
menuBar.DropFilters();
//----
menuBar.addFilters(
new VisualiserMenu("Компиляция", "/icons/Filter.png", true) {
{
for (TableFilter filter : compilationFilters)
add(filter.menuItem);
}
},
new VisualiserMenu("Запуск", "/icons/Filter.png", true) {
{
for (TableFilter filter : runFilters)
add(filter.menuItem);
}
}
);
}
@Override
public String[] getUIColumnNames() {
return new String[]{
"Тест",
@@ -141,7 +153,7 @@ public class TestRunTasksDBTable extends DBTable<Long, TestRunTask> {
};
}
@Override
public Object getFieldAt(TestRunTask object, int columnIndex) {
public Object getFieldAt(DVMRunTask object, int columnIndex) {
switch (columnIndex) {
case 2:
return object.test_description;
@@ -172,23 +184,37 @@ public class TestRunTasksDBTable extends DBTable<Long, TestRunTask> {
}
}
@Override
public Comparator<TestRunTask> getComparator() {
return (o1, o2) -> -o1.getChangeDate().compareTo(o2.getChangeDate());
}
@Override
public Current CurrentName() {
return Current.TestRunTask;
return Current.DVMRunTask;
}
public void ShowDVMPackage(DVMPackage dvmPackage) {
target = dvmPackage;
ClearUI();
Data.clear();
if (dvmPackage.package_json == null) {
if (dvmPackage.getJsonFile().exists()) {
try {
dvmPackage.readJson();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
if (dvmPackage.package_json != null) {
for (DVMCompilationTask compilationTask : dvmPackage.package_json.compilationTasks) {
for (DVMRunTask runTask : compilationTask.runTasks) {
Data.put(runTask.id, runTask);
}
}
ShowUI();
}
}
public void ShowNoPackage() {
ClearUI();
Data.clear();
if (target != null) {
target.destructor();
target = null;
}
@Override
public void ShowUI() {
ResetFiltersCount();
super.ShowUI();
ShowFiltersCount();
}
@Override
public void ShowUI(Object key) {
ResetFiltersCount();
super.ShowUI(key);
ShowFiltersCount();
}
}

115
src/TestingSystem/DVM/DVMTasksSet/DVMRunTasksSet.java
View File

@@ -1,115 +0,0 @@
package TestingSystem.DVM.DVMTasksSet;
import Common.Current;
import Common.Database.DataSet;
import Common.UI.DataSetControlForm;
import TestingSystem.DVM.DVMPackage.DVMPackage;
import TestingSystem.DVM.DVMTasks.DVMCompilationTask;
import TestingSystem.DVM.DVMTasks.DVMRunTask;
import static Common.UI.Tables.TableRenderers.RendererProgress;
import static Common.UI.Tables.TableRenderers.RendererStatusEnum;
public class DVMRunTasksSet extends DataSet<Integer, DVMRunTask> {
public DVMRunTasksSet() {
super(Integer.class, DVMRunTask.class);
}
@Override
public String getSingleDescription() {
return "задача";
}
@Override
public String getPluralDescription() {
return "задачи";
}
@Override
protected DataSetControlForm createUI() {
return new DataSetControlForm(this) {
@Override
public boolean hasCheckBox() {
return true;
}
@Override
protected void AdditionalInitColumns() {
columns.get(5).setRenderer(RendererStatusEnum);
columns.get(6).setRenderer(RendererStatusEnum);
columns.get(13).setRenderer(RendererProgress);
}
};
}
@Override
public String[] getUIColumnNames() {
return new String[]{
"Тест",
"Язык",
"Флаги",
"Компиляция",
"Запуск",
"Матрица",
"Окружение",
"usr.par",
"Время компиляции (с)",
"Время запуска (с)",
"Чистое время (с)",
"Прогресс",
};
}
@Override
public Object getFieldAt(DVMRunTask object, int columnIndex) {
switch (columnIndex) {
case 2:
return object.test_description;
case 3:
return object.language;
case 4:
return object.flags;
case 5:
return object.compilation_state;
case 6:
return object.state;
case 7:
return object.matrix;
case 8:
return object.getEnvironments();
case 9:
return object.getUsrPar();
case 10:
return object.compilation_time;
case 11:
return object.Time;
case 12:
return object.CleanTime;
case 13:
return object.progress;
default:
return null;
}
}
@Override
public Current CurrentName() {
return Current.DVMRunTask;
}
public void ShowDVMPackage(DVMPackage dvmPackage) {
ClearUI();
Data.clear();
if (dvmPackage.package_json == null) {
if (dvmPackage.getJsonFile().exists()) {
try {
dvmPackage.readJson();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
if (dvmPackage.package_json != null) {
for (DVMCompilationTask compilationTask : dvmPackage.package_json.compilationTasks) {
for (DVMRunTask runTask : compilationTask.runTasks) {
Data.put(runTask.id, runTask);
}
}
ShowUI();
}
}
public void ShowNoPackage() {
ClearUI();
Data.clear();
}
}

51
src/TestingSystem/DVM/Tasks/TestCompilationTask.java
View File

@@ -1,51 +0,0 @@
package TestingSystem.DVM.Tasks;
import Common.Database.DBObject;
import TestingSystem.DVM.Configuration.Configuration;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.Test.Test;
import com.sun.org.glassfish.gmbal.Description;
import java.util.Vector;
//-
public class TestCompilationTask extends TestTask {
@Description("DEFAULT ''")
public String makefile_text = "";
@Description("DEFAULT ''")
public String test_home = ""; //место где лежит код теста.
@Description("IGNORE")
public Vector<TestRunTask> runTasks = null;
@Override
public Vector<String> pack(int kernels_in) {
Vector<String> res = new Vector<>();
res.add(String.valueOf(id)); //1
res.add(String.valueOf(maxtime)); //2
res.add(String.valueOf(test_id)); //3
res.add(makefile_text.replace("\n", "|")); //4
//игнор аргумента. ядро всегда одно.
return res;
}
public TestCompilationTask() {
}
public TestCompilationTask(Configuration configuration, Group group, Test test, String flags_in) {
super(configuration, group, test, flags_in);
flags = flags_in;
maxtime = configuration.c_maxtime;
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
TestCompilationTask ct = (TestCompilationTask) src;
makefile_text = ct.makefile_text;
test_home = ct.test_home;
if (ct.runTasks == null) this.runTasks = null;
else {
this.runTasks = new Vector<>();
for (TestRunTask runTask : ct.runTasks) {
this.runTasks.add(new TestRunTask(runTask));
}
}
}
public TestCompilationTask(TestCompilationTask src) {
this.SynchronizeFields(src);
}
}

16
src/TestingSystem/DVM/Tasks/TestCompilationTasksDBTable.java
View File

@@ -1,16 +0,0 @@
package TestingSystem.DVM.Tasks;
import Common.Current;
import Common.Database.DBTable;
public class TestCompilationTasksDBTable extends DBTable<Integer, TestCompilationTask> {
public TestCompilationTasksDBTable() {
super(Integer.class, TestCompilationTask.class);
}
@Override
public String getSingleDescription() {
return "задачи на компиляцию тестов";
}
@Override
public Current CurrentName() {
return Current.TestCompilationTask;
}
}

117
src/TestingSystem/DVM/Tasks/TestRunTask.java
View File

@@ -1,117 +0,0 @@
package TestingSystem.DVM.Tasks;
import Common.Constants;
import Common.Current;
import Common.Database.DBObject;
import Common.Global;
import GlobalData.Tasks.TaskState;
import ProjectData.LanguageName;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.Test.Test;
import TestingSystem.DVM.Configuration.Configuration;
import com.sun.org.glassfish.gmbal.Description;
import java.util.Vector;
public class TestRunTask extends TestTask {
//не факт что тут нужно переводить на полный интерфейс. достаточно убрать фильтрацию
public long testcompilationtask_id = Constants.Nan;
public String matrix = "";
@Description("DEFAULT ''")
public String args = "";
public double CleanTime = 0.0;
@Description("DEFAULT 0")
public int progress = 0;
public LanguageName language = LanguageName.fortran;
public int cube = 1;
public int min_dim = 1;
public int max_dim = 1;
public String environments = "";
public String usr_par = "";
public int compilation_maxtime = 40;
public String compilation_output = "";
public String compilation_errors = "";
public TaskState compilation_state = TaskState.Waiting;
public double compilation_time = 0.0;
public String statistic = "";
public String jsonStatistic = "";
public TestRunTask(Configuration configuration,
Group group, Test test,
String matrix_in, String flags_in,
String environments_in,
String par_in) {
super(configuration, group, test, flags_in);
//--------------------------
//инфа о компиляции.
language = group.language;
compilation_maxtime = configuration.c_maxtime;
compilation_output = "";
compilation_errors = "";
compilation_state = TaskState.Waiting;
//инфа о запуске
cube = configuration.cube;
min_dim = configuration.max_dim_proc_count;
max_dim = configuration.max_dim_proc_count;
maxtime = configuration.r_maxtime;
environments = environments_in;
usr_par = par_in;
args = test.args;
//---------
matrix = matrix_in;
}
public TestRunTask() {
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
TestRunTask rt = (TestRunTask) src;
testcompilationtask_id = rt.testcompilationtask_id;
matrix = rt.matrix;
CleanTime = rt.CleanTime;
progress = rt.progress;
language = rt.language;
cube = rt.cube;
min_dim = rt.min_dim;
max_dim = rt.max_dim;
maxtime = rt.maxtime;
environments = rt.environments;
usr_par = rt.usr_par;
compilation_maxtime = rt.compilation_maxtime;
compilation_output = rt.compilation_output;
compilation_errors = rt.compilation_errors;
compilation_state = rt.compilation_state;
compilation_time = rt.compilation_time;
statistic = rt.statistic;
args = rt.args;
jsonStatistic = rt.jsonStatistic;
}
public TestRunTask(TestRunTask src) {
this.SynchronizeFields(src);
}
//-
@Override
public Vector<String> pack(int kernels_in) {
Vector<String> res = new Vector<>();
res.add(String.valueOf(id)); //1
res.add(String.valueOf(maxtime)); //2
res.add(String.valueOf(testcompilationtask_id)); //3
res.add(matrix); //4
res.add(environments); //5
res.add(usr_par.replace("\n", "|")); //6
res.add(args); //7
res.add(String.valueOf(kernels_in)); //8
return res;
}
//---
public boolean isVisible() {
return
Current.HasTasksPackage() &&
(taskspackage_id==Current.getTasksPackage().id) &&
Global.testingServer.account_db.testRunTasks.applyFilters(this);
}
public String getEnvironments() {
return environments.replace("\n", ";");
}
public String getUsrPar() {
return usr_par.replace("\n", ";");
}
//--
}

99
src/TestingSystem/DVM/Tasks/TestTask.java
View File

@@ -1,99 +0,0 @@
package TestingSystem.DVM.Tasks;
import Common.Constants;
import Common.Database.DBObject;
import GlobalData.Tasks.TaskState;
import TestingSystem.DVM.Configuration.Configuration;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.Test.Test;
import TestingSystem.Common.Test.TestType;
import com.sun.org.glassfish.gmbal.Description;
import java.util.Date;
import java.util.Vector;
//тут все поля должны быть текстовыми. никаких ссылок по ид. мало ли, группу удалят
public class TestTask extends DBObject {
@Description("PRIMARY KEY, UNIQUE")
public long id = Constants.Nan;
@Description("DEFAULT '-1'")
public long taskspackage_id = Constants.Nan;
@Description("DEFAULT -1")
public int group_id = Constants.Nan;
@Description("DEFAULT ''")
public String group_description = ""; //видимое имя группы для юзера
@Description("DEFAULT -1")
public int test_id = Constants.Nan; //ключ - будет генерироваться автоматически.
@Description("DEFAULT ''")
public String test_description = ""; //видимое имя теста для юзера
@Description("DEFAULT ''")
public String flags = "";
@Description("DEFAULT 'Inactive'")
public TaskState state = TaskState.Inactive;
@Description("DEFAULT ''")
public String PID = "";
@Description("DEFAULT 40")
public int maxtime = 40;
@Description("DEFAULT ''")
public String remote_workspace = ""; //вывести. память экономим.
@Description("DEFAULT ''")
public String binary_name = ""; //вывести. имя генерим по ид задачи и матрице.
@Description("DEFAULT 'Default'")
public TestType test_type = TestType.Default;
//результаты-------------------------------
public double Time; //время выполнения.
public long StartDate = 0; //дата начала выполнения
public long ChangeDate = 0;//дата изменения
@Description("DEFAULT ''")
public String output = "";
@Description("DEFAULT ''")
public String errors = "";
//------------------------------------------------------
@Override
public Object getPK() {
return id;
}
public Date getChangeDate() {
return new Date(ChangeDate);
}
//--->>>
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
TestTask t = (TestTask) src;
id = t.id;
taskspackage_id = t.taskspackage_id;
group_id = t.group_id;
group_description = t.group_description;
test_id = t.test_id;
test_description = t.test_description;
flags = t.flags;
state = t.state;
PID = t.PID;
maxtime = t.maxtime;
remote_workspace = t.remote_workspace;
binary_name = t.binary_name;
test_type = t.test_type;
Time = t.Time;
StartDate = t.StartDate;
ChangeDate = t.ChangeDate;
output = t.output;
errors = t.errors;
}
public TestTask(TestTask src) {
this.SynchronizeFields(src);
}
public TestTask() {
}
public TestTask(Configuration configuration,
Group group, Test test, String flags_in) {
group_id = group.id;
test_id = test.id;
group_description = group.description;
test_description = test.description;
test_type = group.type;
flags = flags_in;
}
public Vector<String> pack (int kernels){
return null;
}
}

89
src/TestingSystem/DVM/TasksPackage/TasksPackage.java
View File

@@ -1,89 +0,0 @@
package TestingSystem.DVM.TasksPackage;
import Common.Constants;
import Common.Database.DBObject;
import GlobalData.Machine.MachineType;
import TestingSystem.DVM.Tasks.TestCompilationTask;
import com.sun.org.glassfish.gmbal.Description;
import java.util.LinkedHashMap;
import java.util.Vector;
public class TasksPackage extends DBObject {
@Description("PRIMARY KEY, UNIQUE")
public long id = Constants.Nan;
public String pid=""; //сишная часть.
public String summary = "";
//---
public String dvm_version = "?";
public String dvm_drv = "";
//---
public String machine_name = "";
public String machine_address = "";
public int machine_port = 22;
public MachineType machine_type;
public String user_name = "";
public String user_password;
public String user_workspace;
//---
public int compilationTasksCount = 0;
public int runTasksCount = 0;
public int needsEmail = 0;
//---
public double Time; //время выполнения.
public long StartDate = 0; //дата начала выполнения
public long ChangeDate = 0;//дата окончания выполнения
//-
@Description("DEFAULT 1")
public int kernels = 1;
//-
public TasksPackageState state = TasksPackageState.Queued;
//--
//нужно только для публикации задач.
public LinkedHashMap<Integer, LinkedHashMap<Integer, Vector<TestCompilationTask>>> sorted_tasks = new LinkedHashMap<>();
@Override
public Object getPK() {
return id;
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
TasksPackage tasksPackage = (TasksPackage) src;
pid = tasksPackage.pid;
summary = tasksPackage.summary;
dvm_drv = tasksPackage.dvm_drv;
dvm_version = tasksPackage.dvm_version;
machine_name = tasksPackage.machine_name;
machine_address = tasksPackage.machine_address;
machine_port = tasksPackage.machine_port;
machine_type = tasksPackage.machine_type;
user_name = tasksPackage.user_name;
user_workspace = tasksPackage.user_workspace;
user_password = tasksPackage.user_password;
compilationTasksCount = tasksPackage.compilationTasksCount;
runTasksCount = tasksPackage.runTasksCount;
needsEmail = tasksPackage.needsEmail;
Time = tasksPackage.Time;
StartDate = tasksPackage.StartDate;
ChangeDate = tasksPackage.ChangeDate;
sorted_tasks = new LinkedHashMap<>();
kernels = tasksPackage.kernels;
state = tasksPackage.state;
//-
for (int group_id : tasksPackage.sorted_tasks.keySet()) {
LinkedHashMap<Integer, Vector<TestCompilationTask>> src_groupTasks = tasksPackage.sorted_tasks.get(group_id);
LinkedHashMap<Integer, Vector<TestCompilationTask>> dst_groupTasks = new LinkedHashMap<>();
for (int test_id : src_groupTasks.keySet()) {
Vector<TestCompilationTask> src_testTasks = src_groupTasks.get(test_id);
Vector<TestCompilationTask> dst_testTasks = new Vector<>();
for (TestCompilationTask src_testCompilationTask : src_testTasks)
dst_testTasks.add(new TestCompilationTask(src_testCompilationTask));
dst_groupTasks.put(test_id, dst_testTasks);
}
sorted_tasks.put(group_id, dst_groupTasks);
}
}
public TasksPackage(TasksPackage src) {
this.SynchronizeFields(src);
}
public TasksPackage() {
}
}

100
src/TestingSystem/DVM/TasksPackage/TasksPackageDBTable.java
View File

@@ -1,100 +0,0 @@
package TestingSystem.DVM.TasksPackage;
import Common.Current;
import Common.Database.*;
import Common.UI.DataSetControlForm;
import Common.UI.UI;
import TestingSystem.DVM.Tasks.TestRunTask;
import java.util.Date;
import java.util.LinkedHashMap;
import static Common.UI.Tables.TableRenderers.RendererDate;
import static Common.UI.Tables.TableRenderers.RendererStatusEnum;
public class TasksPackageDBTable extends DBTable<Long,TasksPackage> {
public TasksPackageDBTable() {
super(Long.class,TasksPackage.class);
}
@Override
public Current CurrentName() {
return Current.TasksPackage;
}
@Override
public String getSingleDescription() {
return "пакет задач";
}
@Override
public String getPluralDescription() {
return "пакеты задач";
}
@Override
protected DataSetControlForm createUI() {
return new DataSetControlForm(this) {
@Override
public boolean hasCheckBox() {
return true;
}
@Override
protected void AdditionalInitColumns() {
// columns.get(0).setVisible(false);
columns.get(7).setRenderer(RendererDate);
columns.get(8).setRenderer(RendererDate);
columns.get(9).setRenderer(RendererStatusEnum);
}
@Override
public void ShowCurrentObject() throws Exception {
super.ShowCurrentObject();
UI.getMainWindow().getTestingWindow().DropTestRunTasksComparison();
}
@Override
public void ShowNoCurrentObject() throws Exception {
super.ShowNoCurrentObject();
UI.getMainWindow().getTestingWindow().DropTestRunTasksComparison();
}
};
}
@Override
public String[] getUIColumnNames() {
return new String[]{
"Машина",
"Пользователь",
"DVM",
"Задач",
"Ядер",
"Начало",
"Изменено",
"Статус"
};
}
@Override
public Object getFieldAt(TasksPackage object, int columnIndex) {
switch (columnIndex) {
case 2:
return object.machine_address + ":" + object.machine_port;
case 3:
return object.user_name;
case 4:
return object.dvm_version;
case 5:
return object.runTasksCount;
case 6:
return object.kernels;
case 7:
return new Date(object.StartDate);
case 8:
return new Date(object.ChangeDate);
case 9:
return object.state;
default:
return null;
}
}
@Override
public LinkedHashMap<Class<? extends DBObject>, FKBehaviour> getFKDependencies() {
LinkedHashMap<Class<? extends DBObject>, FKBehaviour> res = new LinkedHashMap<>();
res.put(TestRunTask.class, new FKBehaviour(FKDataBehaviour.DELETE, FKCurrentObjectBehaviuor.ACTIVE));
return res;
}
}

281
src/TestingSystem/DVM/TestsSupervisor_2022.java
View File

@@ -1,281 +0,0 @@
package TestingSystem.DVM;
import Common.Constants;
import Common.Global;
import Common.Utils.Utils;
import GlobalData.RemoteFile.RemoteFile;
import GlobalData.Tasks.TaskState;
import Repository.Server.ServerCode;
import TestingSystem.Common.Test.TestType;
import TestingSystem.Common.TestingPlanner_OLD;
import TestingSystem.DVM.Tasks.TestCompilationTask;
import TestingSystem.DVM.Tasks.TestRunTask;
import TestingSystem.DVM.Tasks.TestTask;
import TestingSystem.DVM.TasksPackage.TasksPackage;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import Visual_DVM_2021.Passes.All.UnzipFolderPass;
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.*;
public class TestsSupervisor_2022 {
protected TestingPlanner_OLD planner; //планировщик.
protected UserConnection connection;
protected TasksPackage tasksPackage;
protected RemoteFile packageRemoteWorkspace;
protected File packageLocalWorkspace;
protected Vector<TestCompilationTask> compilationTasks; //список задач на компиляцию
protected int count = 0; //число активных задач.
//----
public TestsSupervisor_2022(TestingPlanner_OLD planner_in, UserConnection connection_in, TasksPackage tasksPackage_in, Vector<TestCompilationTask> tasks_in) {
planner = planner_in;
connection = connection_in;
tasksPackage = tasksPackage_in;
compilationTasks = tasks_in;
packageRemoteWorkspace = new RemoteFile(tasksPackage.user_workspace + "/tests", String.valueOf(tasksPackage.id), true);
packageLocalWorkspace = new File(Global.PackagesDirectory, String.valueOf(tasksPackage.id));
}
public boolean packageNeedsKill() throws Exception {
return (boolean) planner.ServerCommand(ServerCode.CheckPackageToKill, tasksPackage.id);
}
public void Perform() throws Exception {
if (packageNeedsKill()) {
System.out.println("PACKAGE " + tasksPackage.id + " NEEDS TO KILL");
if (!tasksPackage.pid.isEmpty()) {
connection.ShellCommand("kill -9 " + tasksPackage.pid);
}
tasksPackage.state = TasksPackageState.Aborted;
planner.UpdatePackage();
} else {
switch (tasksPackage.state) {
case TestsSynchronize:
TestsSynchronize();
tasksPackage.state = TasksPackageState.PackageWorkspaceCreation;
planner.UpdatePackage();
break;
case PackageWorkspaceCreation:
PackageWorkspaceCreation();
tasksPackage.state = TasksPackageState.PackageStart;
planner.UpdatePackage();
break;
case PackageStart:
PackageStart();
tasksPackage.state = TasksPackageState.CompilationWorkspacesCreation;
planner.UpdatePackage();
break;
case CompilationWorkspacesCreation:
case CompilationPreparation:
case CompilationExecution:
case RunningWorkspacesCreation:
case RunningPreparation:
case RunningExecution:
checkNextState();
break;
case RunningEnd:
DownloadResults();
tasksPackage.state = TasksPackageState.Analysis;
planner.UpdatePackage();
break;
case Analysis:
AnalyseResults();
tasksPackage.state = TasksPackageState.Done;
planner.UpdatePackage();
break;
default:
break;
}
}
}
private void TestsSynchronize() throws Exception {
//1, получить набор уникальных тестов.
Vector<String> test_ids = new Vector<>();
for (TestCompilationTask current_task : compilationTasks)
if (!test_ids.contains(current_task.test_id))
test_ids.add(String.valueOf(current_task.test_id));
//синхронизировать их.
for (String test_id : test_ids) {
File test_src = Paths.get(Global.TestsDirectory.getAbsolutePath(), test_id).toFile();
RemoteFile test_dst = new RemoteFile(tasksPackage.user_workspace + "/projects/" + test_id, true);
connection.MKDIR(test_dst);
connection.SynchronizeSubDirsR(test_src, test_dst);
}
}
private void PackageWorkspaceCreation() throws Exception {
//создать папку для пакета.
connection.sftpChannel.mkdir(packageRemoteWorkspace.full_name);
//положить туда запакованные тексты задач.
Vector<String> compilationLines = new Vector<>();
Vector<String> runLines = new Vector<>();
for (TestCompilationTask compilationTask : planner.packageTasks.values()) {
compilationLines.addAll(compilationTask.pack(1));
for (TestRunTask runTask : compilationTask.runTasks) {
int rt_kernels = (runTask.test_type == TestType.Performance) ? tasksPackage.kernels :
Math.min(Utils.getMatrixProcessors(runTask.matrix), tasksPackage.kernels);
runLines.addAll(runTask.pack(rt_kernels));
}
}
RemoteFile compilationPackage = new RemoteFile(packageRemoteWorkspace, "compilationTasks");
RemoteFile runPackage = new RemoteFile(packageRemoteWorkspace, "runTasks");
connection.writeToFile(String.join("\n", compilationLines) + "\n", compilationPackage);
connection.writeToFile(String.join("\n", runLines) + "\n", runPackage);
// --
connection.MKDIR(new RemoteFile(packageRemoteWorkspace, "state"));
}
private void PackageStart() throws Exception {
String plannerStartCommand =
String.join(" ",
"nohup",
Utils.DQuotes(planner.getPlanner()),
Utils.DQuotes(tasksPackage.user_workspace),
Utils.DQuotes(packageRemoteWorkspace.full_name),
Utils.DQuotes(tasksPackage.kernels),
Utils.DQuotes(tasksPackage.dvm_drv),
"&"
);
connection.ShellCommand(plannerStartCommand);
RemoteFile PID = new RemoteFile(packageRemoteWorkspace, "PID");
RemoteFile STARTED = new RemoteFile(packageRemoteWorkspace, "STARTED");
while (!connection.Exists(STARTED)) {
System.out.println("waiting for package start...");
Utils.sleep(1000);
}
if (connection.Exists(PID)) {
tasksPackage.pid = connection.readFromFile(PID);
}
}
public void checkNextState() throws Exception {
RemoteFile stateDir = new RemoteFile(packageRemoteWorkspace, "state");
//состояния пакета могут меняться только по возрастанию. ищем, появилось ли такое.
Vector<TasksPackageState> higherStates = tasksPackage.state.getHigherStates();
Collections.reverse(higherStates); //берем в обратном порядке, чтобы быстрее найти высшее.
for (TasksPackageState state : higherStates) {
RemoteFile file = new RemoteFile(stateDir, state.toString());
if (connection.Exists(file)) {
System.out.println("found new state: " + file.name);
tasksPackage.state = state;
planner.UpdatePackage();
return;
}
}
}
public void DownloadResults() throws Exception {
Utils.CheckDirectory(packageLocalWorkspace);
RemoteFile remote_results_archive = new RemoteFile(packageRemoteWorkspace, "results.zip");
File results_archive = new File(packageLocalWorkspace, "results.zip");
connection.performScript(packageRemoteWorkspace, "zip -r " + Utils.DQuotes("results.zip") + " " + Utils.DQuotes("results"));
//---
if (connection.Exists(remote_results_archive)) {
connection.getSingleFile(remote_results_archive.full_name, results_archive.getAbsolutePath());
UnzipFolderPass unzipFolderPass = new UnzipFolderPass();
unzipFolderPass.Do(results_archive.getAbsolutePath(), packageLocalWorkspace.getAbsolutePath(), false);
}
//получили результат. теперь уничтожаем папку пакета на целевой машине.
if (connection.Exists(packageRemoteWorkspace)){
connection.RMDIR(packageRemoteWorkspace.full_name);
}
}
public void getTasksInfo(Vector<? extends TestTask> tasks, String file_name) throws Exception {
LinkedHashMap<Long, TestTask> sorted_tasks = new LinkedHashMap<>();
for (TestTask task : tasks)
sorted_tasks.put(task.id, task);
//--
File info_file = Paths.get(packageLocalWorkspace.getAbsolutePath(), "results", file_name).toFile();
List<String> lines = FileUtils.readLines(info_file, Charset.defaultCharset());
for (String packed : lines) {
if (!packed.isEmpty()) {
String[] data = packed.split(" ");
long id = Long.parseLong(data[0]);
TaskState state = TaskState.valueOf(data[1]);
double time = Double.parseDouble(data[2]);
//--
TestTask task = sorted_tasks.get(id);
task.state = state;
task.Time = state.equals(TaskState.AbortedByTimeout)?(task.maxtime+1):time;
}
}
}
public void AnalyseResults() throws Exception {
System.out.println("analysing results");
Vector<TestRunTask> runTasks = new Vector<>();
for (TestCompilationTask compilationTask : compilationTasks)
runTasks.addAll(compilationTask.runTasks);
//----
getTasksInfo(compilationTasks, "CompilationInfo.txt");
getTasksInfo(runTasks, "RunningInfo.txt");
//--
int ct_count = 0;
int rt_count = 0;
//--
for (TestCompilationTask testCompilationTask : compilationTasks) {
ct_count++;
if (readTask(testCompilationTask)) {
for (TestRunTask testRunTask : testCompilationTask.runTasks) {
rt_count++;
testRunTask.compilation_state = testCompilationTask.state;
testRunTask.compilation_output = testCompilationTask.output;
testRunTask.compilation_errors = testCompilationTask.errors;
testRunTask.compilation_time = testCompilationTask.Time;
if (testCompilationTask.state == TaskState.DoneWithErrors) {
testRunTask.state = TaskState.Canceled;
} else {
readTask(testRunTask);
}
if (testRunTask.state.equals(TaskState.Finished)) {
//анализ задачи на запуск.
List<String> output_lines = Arrays.asList(testRunTask.output.split("\n"));
List<String> errors_lines = Arrays.asList(testRunTask.errors.split("\n"));
//---
if (Utils.isCrushed(output_lines, errors_lines)) {
testRunTask.state = TaskState.Crushed;
} else {
Pair<TaskState, Integer> results = new Pair<>(TaskState.Done, 100);
switch (testRunTask.test_type) {
case Correctness:
results = Utils.analyzeCorrectness(output_lines);
break;
case Performance:
results = Utils.analyzePerformance(output_lines);
break;
default:
break;
}
testRunTask.state = results.getKey();
testRunTask.progress = results.getValue();
testRunTask.CleanTime = Utils.parseCleanTime(testRunTask.output);
}
}
}
}
}
System.out.println("ct_count=" + ct_count + " rt count=" + rt_count);
//теперь обновить их единым списком, и удалить задачи на компиляцию.
planner.ServerCommand(ServerCode.UpdateTestTasks, compilationTasks);
//--
System.out.println("cleaning results on server");
Utils.forceDeleteWithCheck(packageLocalWorkspace);
System.out.println("done");
}
public boolean readTask(TestTask testTask) throws Exception {
File taskWorkspace = Paths.get(packageLocalWorkspace.getAbsolutePath(), "results", String.valueOf(testTask.id)).toFile();
if (taskWorkspace.exists()) {
System.out.println("id=" + testTask.id + ": path=" + taskWorkspace.getAbsolutePath());
File outFile = new File(taskWorkspace, Constants.out_file);
File errFile = new File(taskWorkspace.getAbsolutePath(), Constants.err_file);
File stsFile = new File(taskWorkspace.getAbsolutePath(), "statistic.txt");
if (outFile.exists())
testTask.output = FileUtils.readFileToString(outFile);
if (errFile.exists())
testTask.errors = FileUtils.readFileToString(errFile);
if ((testTask instanceof TestRunTask) && stsFile.exists()) {
TestRunTask testRunTask = (TestRunTask) testTask;
testRunTask.statistic = FileUtils.readFileToString(stsFile);
}
return true;
}
return false;
}
}

4
src/TestingSystem/SAPFOR/Json/SapforTasksResults_json.java
View File

@@ -3,8 +3,6 @@ import Common.Utils.Utils;
import GlobalData.Tasks.TaskState;
import TestingSystem.SAPFOR.SapforTask.MatchState;
import TestingSystem.SAPFOR.SapforTask.SapforTask;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import TestingSystem.SAPFOR.SapforTasksPackage.UI.*;
import com.google.gson.annotations.Expose;
import javax.swing.tree.DefaultMutableTreeNode;
@@ -15,6 +13,7 @@ import java.util.LinkedHashMap;
import java.util.List;
import java.util.Vector;
public class SapforTasksResults_json implements Serializable {
/*
//---
public PackageSummary root = null;
public PackageSummary comparison_root = null;
@@ -264,4 +263,5 @@ public class SapforTasksResults_json implements Serializable {
return res;
}
//---
*/
}

3
src/TestingSystem/SAPFOR/SapforPackage/SapforPackage.java
View File

@@ -39,4 +39,7 @@ public class SapforPackage extends TestingPackage<SapforTasksPackage_json> {
public File getHomeDirectory() {
return Global.SapforPackagesDirectory;
}
public boolean isLoaded() {
return false;
}
}

2
src/TestingSystem/SAPFOR/SapforTask/SapforTask.java
View File

@@ -144,10 +144,12 @@ public class SapforTask extends DBObject {
}
return String.join("→", versionsLines);
}
/*
@Override
public boolean isVisible() {
return Current.HasSapforTasksPackage() && Current.getSapforTasksPackage().id == this.sapfortaskspackage_id;
}
*/
public LinkedHashMap<String, SapforVersion_json> getSortedVersions() {
LinkedHashMap<String, SapforVersion_json> res = new LinkedHashMap<>();
for (SapforVersion_json version_json : versions)

68
src/TestingSystem/SAPFOR/SapforTask/SapforTasksDBTable.java
View File

@@ -1,68 +0,0 @@
package TestingSystem.SAPFOR.SapforTask;
import Common.Current;
import Common.Database.DBTable;
import Common.UI.DataSetControlForm;
import static Common.UI.Tables.TableRenderers.RendererDate;
import static Common.UI.Tables.TableRenderers.RendererStatusEnum;
public class SapforTasksDBTable extends DBTable<Long, SapforTask> {
public SapforTasksDBTable() {
super(Long.class, SapforTask.class);
}
@Override
public String getSingleDescription() {
return "задача";
}
@Override
public String getPluralDescription() {
return "задачи";
}
@Override
public Current CurrentName() {
return Current.SapforTask;
}
@Override
protected DataSetControlForm createUI() {
return new DataSetControlForm(this) {
@Override
protected void AdditionalInitColumns() {
columns.get(4).setRenderer(RendererStatusEnum);
columns.get(5).setRenderer(RendererDate);
columns.get(6).setRenderer(RendererDate);
}
};
}
@Override
public String[] getUIColumnNames() {
return new String[]{
"Группа",
"Тест",
"Флаги",
"Статус",
"Начало",
"Окончание",
"Версии"
};
}
@Override
public Object getFieldAt(SapforTask object, int columnIndex) {
switch (columnIndex) {
case 1:
return object.group_description;
case 2:
return object.test_description;
case 3:
return object.flags;
case 4:
return object.state;
case 5:
return object.getStartDate();
case 6:
return object.getChangeDate();
case 7:
return object.versionsDescription;
default:
return null;
}
}
}

17
src/TestingSystem/SAPFOR/SapforTasksPackage/SapforPackageData.java
View File

@@ -1,17 +0,0 @@
package TestingSystem.SAPFOR.SapforTasksPackage;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.Test.Test;
import TestingSystem.SAPFOR.SapforConfiguration.SapforConfiguration;
import TestingSystem.SAPFOR.ServerSapfor.ServerSapfor;
import java.io.Serializable;
import java.util.LinkedHashMap;
public class SapforPackageData implements Serializable {
//--->
public LinkedHashMap<Integer, Group> groups =new LinkedHashMap<Integer, Group>();
public LinkedHashMap<Integer, Test> tests = new LinkedHashMap<>();
public LinkedHashMap<Integer, SapforConfiguration> sapforConfigurations = new LinkedHashMap<>();
public ServerSapfor sapfor = null;
//-->>
public String notFound = "";
}

103
src/TestingSystem/SAPFOR/SapforTasksPackage/SapforTasksPackage.java
View File

@@ -1,103 +0,0 @@
package TestingSystem.SAPFOR.SapforTasksPackage;
import Common.Constants;
import Common.Database.DBObject;
import Common.Global;
import Common.Utils.Utils;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import TestingSystem.SAPFOR.Json.SapforTasksResults_json;
import TestingSystem.SAPFOR.SapforTask.SapforTask;
import com.sun.org.glassfish.gmbal.Description;
import java.io.File;
import java.nio.file.Paths;
import java.util.Comparator;
public class SapforTasksPackage extends DBObject {
@Description("PRIMARY KEY, UNIQUE")
public long id = Constants.Nan;
@Description("DEFAULT ''")
public String testsNames = "";//имена тестов через ; для отображения
//---
public int sapforId = Constants.Nan;
public String sapfor_version = "?"; //тестируемая версия SAPFOR для таблицы
public String sapfor_process_name = "";
//---
public String workspace = ""; //домашняя папка
//---
public int tasksCount = 0; //Общее число задач
//---
public int needsEmail = 0;
public long StartDate = 0; //дата начала выполнения
public long ChangeDate = 0;//дата окончания выполнения
//-
public int kernels = 1; //количество потоков.
@Description("DEFAULT 'TestsSynchronize'")
public TasksPackageState state = TasksPackageState.TestsSynchronize;
@Description("DEFAULT ''")
public String testsIds = "";
@Description("DEFAULT ''")
public String configurationsIds = "";
@Description("DEFAULT ''")
public String summary = "";
@Description("IGNORE")
public SapforTasksResults_json results = null;
///---
public File getArchive() {
return new File(Global.SapforPackagesDirectory, id + ".zip");
}
public File getLocalWorkspace() {
return new File(Global.SapforPackagesDirectory, String.valueOf(id));
}
public File getLoadedSign() {
return Paths.get(Global.SapforPackagesDirectory.getAbsolutePath(), String.valueOf(id), Constants.LOADED).toFile();
}
public boolean isLoaded() {
return getLoadedSign().exists();
}
public void readResults() {
File json_file = new File(getLocalWorkspace(), Constants.results_json);
results = null;
try {
results = (SapforTasksResults_json) Utils.jsonFromFile(json_file,
SapforTasksResults_json.class);
//----
results.tasks.sort(Comparator.comparing(SapforTask::getUniqueKey));
for (SapforTask task : results.tasks)
results.allTasks.put(task.getUniqueKey(), task);
//---
results.SortTasks(); //по состояниям конфигурациям и группам
//---
results.buildTree(this);
//---
} catch (Exception ex) {
ex.printStackTrace();
}
}
@Override
public Object getPK() {
return id;
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
SapforTasksPackage p = (SapforTasksPackage) src;
sapforId = p.sapforId;
testsNames = p.testsNames;
sapfor_version = p.sapfor_version;
workspace = p.workspace;
tasksCount = p.tasksCount;
StartDate = p.StartDate;
ChangeDate = p.ChangeDate;
kernels = p.kernels;
sapfor_process_name = p.sapfor_process_name;
state = p.state;
needsEmail = p.needsEmail;
summary = p.summary;
}
//---
public SapforTasksPackage() {
}
//--
public SapforTasksPackage(SapforTasksPackage sapforTasksPackage) {
this.SynchronizeFields(sapforTasksPackage);
}
}

85
src/TestingSystem/SAPFOR/SapforTasksPackage/SapforTasksPackagesDBTable.java
View File

@@ -1,85 +0,0 @@
package TestingSystem.SAPFOR.SapforTasksPackage;
import Common.Current;
import Common.Database.*;
import Common.UI.DataSetControlForm;
import TestingSystem.SAPFOR.SapforTask.SapforTask;
import java.util.Date;
import java.util.LinkedHashMap;
import static Common.UI.Tables.TableRenderers.RendererDate;
import static Common.UI.Tables.TableRenderers.RendererStatusEnum;
public class SapforTasksPackagesDBTable extends DBTable<Long,SapforTasksPackage> {
public SapforTasksPackagesDBTable() {
super(Long.class,SapforTasksPackage.class);
}
@Override
public Current CurrentName() {
return Current.SapforTasksPackage;
}
@Override
public String getSingleDescription() {
return "пакет задач Sapfor";
}
@Override
public String getPluralDescription() {
return "пакеты задач Sapfor";
}
@Override
protected DataSetControlForm createUI() {
return new DataSetControlForm(this) {
@Override
public boolean hasCheckBox() {
return true;
}
@Override
protected void AdditionalInitColumns() {
// columns.get(0).setVisible(false);
columns.get(3).setMaxWidth(200);
columns.get(6).setRenderer(RendererDate);
columns.get(7).setRenderer(RendererDate);
columns.get(8).setRenderer(RendererStatusEnum);
}
};
}
@Override
public String[] getUIColumnNames() {
return new String[]{
"SAPFOR",
"Тесты",
"Задач",
"Ядер",
"Начало",
"Изменено",
"Статус"
};
}
@Override
public Object getFieldAt(SapforTasksPackage object, int columnIndex) {
switch (columnIndex) {
case 2:
return object.sapfor_version;
case 3:
return object.testsNames;
case 4:
return object.tasksCount;
case 5:
return object.kernels;
case 6:
return new Date(object.StartDate);
case 7:
return new Date(object.ChangeDate);
case 8:
return object.state;
default:
return null;
}
}
@Override
public LinkedHashMap<Class<? extends DBObject>, FKBehaviour> getFKDependencies() {
LinkedHashMap<Class<? extends DBObject>, FKBehaviour> res = new LinkedHashMap<>();
res.put(SapforTask.class, new FKBehaviour(FKDataBehaviour.DELETE, FKCurrentObjectBehaviuor.ACTIVE));
return res;
}
}

208
src/TestingSystem/SAPFOR/SapforTasksPackageSupervisor/SapforTasksPackageSupervisor.java
View File

@@ -1,208 +0,0 @@
package TestingSystem.SAPFOR.SapforTasksPackageSupervisor;
import Common.Constants;
import Common.Current;
import Common.Global;
import Common.GlobalProperties;
import Common.Utils.Utils;
import Repository.Server.ServerCode;
import TestingSystem.Common.Test.Test;
import TestingSystem.Common.TestingPlanner_OLD;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import TestingSystem.SAPFOR.Json.SapforConfiguration_json;
import TestingSystem.SAPFOR.Json.SapforTasksPackage_json;
import TestingSystem.SAPFOR.Json.SapforTasksResults_json;
import TestingSystem.SAPFOR.Json.SapforTest_json;
import TestingSystem.SAPFOR.SapforConfiguration.SapforConfiguration;
import TestingSystem.SAPFOR.SapforTask.SapforTask;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforPackageData;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import Visual_DVM_2021.Passes.PassCode_2021;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.util.Date;
import java.util.Vector;
public class SapforTasksPackageSupervisor {
protected TestingPlanner_OLD planner; //планировщик.
SapforTasksPackage sapforTasksPackage = null;
public SapforTasksPackageSupervisor(TestingPlanner_OLD planner_in, SapforTasksPackage sapforTasksPackage_in) {
planner = planner_in;
sapforTasksPackage = sapforTasksPackage_in;
}
private void TestsSynchronize() throws Exception {
SapforPackageData data = (SapforPackageData) planner.ServerCommand(ServerCode.GetActualSapforPackageData, sapforTasksPackage);
if (!data.notFound.isEmpty()) {
sapforTasksPackage.summary = data.notFound;
sapforTasksPackage.state = TasksPackageState.Aborted;
return;
}
//--
System.out.println(sapforTasksPackage.id + " — TestsSynchronize");
File sapfor_src = new File(data.sapfor.call_command);
//--
SapforTasksPackage_json package_json = new SapforTasksPackage_json();
package_json.kernels = sapforTasksPackage.kernels;
for (Test test : data.tests.values()) {
SapforTest_json test_json = new SapforTest_json();
test_json.description = test.description;
test_json.group_description = data.groups.get(test.group_id).description;
package_json.tests.add(test_json);
}
//создание рабочего пространства для пакетного режима
File packageWorkspace = new File(Global.SapforPackagesDirectory, String.valueOf(sapforTasksPackage.id));
Utils.CheckAndCleanDirectory(packageWorkspace);
sapforTasksPackage.workspace = packageWorkspace.getAbsolutePath();
//копирование тестов по конфигурациям.
int actual_tasks_count = 0;
for (SapforConfiguration configuration : data.sapforConfigurations.values()) {
//--
SapforConfiguration_json configuration_json = new SapforConfiguration_json();
configuration_json.id = configuration.id;
configuration_json.flags = configuration.getFlags();
configuration_json.codes.add(PassCode_2021.SPF_CorrectCodeStylePass); //всегда добавляется.
configuration_json.codes.addAll(configuration.getPassCodes());
//--->>
package_json.configurations.add(configuration_json);
//-->>
File configurationWorkspace = new File(packageWorkspace, String.valueOf(configuration.id));
FileUtils.forceMkdir(configurationWorkspace);
//--->>>
for (Test test : data.tests.values()) {
File test_root = new File(configurationWorkspace, test.description);
Utils.CheckAndCleanDirectory(test_root);
FileUtils.copyDirectory(new File(Global.TestsDirectory, String.valueOf(test.id)), test_root);
actual_tasks_count++;
}
}
sapforTasksPackage.tasksCount = actual_tasks_count;
//копирование SAPFOR
File sapforFile = new File(sapforTasksPackage.workspace, Utils.getDateName("SAPFOR_F"));
FileUtils.copyFile(sapfor_src, sapforFile);
if (!sapforFile.setExecutable(true))
throw new Exception("Не удалось сделать файл " + sapforFile.getName() + " исполняемым!");
sapforTasksPackage.sapfor_process_name = package_json.sapfor_drv = sapforFile.getName();
//--->>
//копирование визуализатора
File visualiser = new File(sapforTasksPackage.workspace, "VisualSapfor.jar");
FileUtils.copyFile(new File(Global.Home, "TestingSystem.jar"), visualiser);
//создание настроек
GlobalProperties properties = new GlobalProperties();
properties.Mode = Current.Mode.Package;
Utils.jsonToFile(properties, new File(sapforTasksPackage.workspace, "properties"));
//создание инструкции
File package_json_file = new File(sapforTasksPackage.workspace, "package_json");
Utils.jsonToFile(package_json, package_json_file);
//подготовка пакетного режима. Запустит его уже очередь.
Utils.createScript(packageWorkspace, packageWorkspace, "start", "java -jar VisualSapfor.jar");
//--
sapforTasksPackage.state = TasksPackageState.RunningPreparation;
}
void PackageStart() throws Exception {
System.out.println("start sapfor package " + sapforTasksPackage.id);
File workspace = new File(sapforTasksPackage.workspace);
File script = new File(sapforTasksPackage.workspace, "start");
ProcessBuilder procBuilder = new ProcessBuilder(script.getAbsolutePath());
procBuilder.directory(workspace);
procBuilder.start();
//--->>
File started = new File(sapforTasksPackage.workspace, Constants.STARTED);
while (!started.exists()) {
System.out.println("waiting for package start...");
Utils.sleep(1000);
}
//-->>
sapforTasksPackage.state = TasksPackageState.RunningExecution;
planner.UpdateSapforPackage();
System.out.println("done");
}
void CheckPackageState() throws Exception {
System.out.println("check sapfor package " + sapforTasksPackage.id);
File done = new File(sapforTasksPackage.workspace, Constants.DONE);
File aborted = new File(sapforTasksPackage.workspace, Constants.ABORTED);
if (done.exists()) {
sapforTasksPackage.state = TasksPackageState.Analysis;
planner.UpdateSapforPackage();
System.out.println("package done, start Analysis");
} else if (aborted.exists()) {
sapforTasksPackage.state = TasksPackageState.Aborted;
planner.UpdateSapforPackage();
System.out.println("package aborted");
} else {
System.out.println("package running");
}
}
//--
public boolean packageNeedsKill() throws Exception {
return (boolean) planner.ServerCommand(ServerCode.CheckPackageToKill, sapforTasksPackage.id);
}
public void killPackage() throws Exception {
//----
File interrupt_file = new File(sapforTasksPackage.workspace, Constants.INTERRUPT);
//----
FileUtils.writeStringToFile(interrupt_file, new Date().toString());
File aborted_file = new File(sapforTasksPackage.workspace, Constants.ABORTED);
do {
System.out.println("waiting for interrupt...");
Thread.sleep(1000);
} while (!aborted_file.exists());
System.out.println("coup de grace..");
String kill_command = "killall -SIGKILL " + sapforTasksPackage.sapfor_process_name;
System.out.println(kill_command);
Process killer = Runtime.getRuntime().exec(kill_command);
killer.waitFor();
System.out.println("done!");
}
public void AnalysePackage() throws Exception {
File results_json_file = new File(sapforTasksPackage.workspace, Constants.results_json);
if (results_json_file.exists()) {
SapforTasksResults_json results_json = (SapforTasksResults_json) Utils.jsonFromFile(results_json_file, SapforTasksResults_json.class);
results_json.SortTasks();
//--
sapforTasksPackage.summary = results_json.getEmailSummary();
for (SapforTask task : results_json.tasks) {
//--
task.versions = null;
task.variants = null;
}
planner.ServerCommand(ServerCode.PublishSapforPackageTasks, planner.email, new Vector<>(results_json.tasks));
}
//Очистка
//очистка служебных файлов.
Utils.deleteFilesByExtensions(new File(sapforTasksPackage.workspace),
"proj", "dep", "jar"
// ,"sh", "exe", "bat"
);
//удаление сапфора
File sapfor = new File(sapforTasksPackage.workspace, sapforTasksPackage.sapfor_process_name);
if (sapfor.exists())
FileUtils.forceDelete(sapfor);
}
public void Perform() throws Exception {
if (packageNeedsKill()) {
System.out.println("PACKAGE " + sapforTasksPackage.id + " NEEDS TO KILL");
killPackage();
sapforTasksPackage.state = TasksPackageState.Aborted;
planner.UpdateSapforPackage();
} else {
switch (sapforTasksPackage.state) {
case TestsSynchronize:
TestsSynchronize();
planner.UpdateSapforPackage();
break;
case RunningPreparation:
PackageStart();
break;
case RunningExecution:
CheckPackageState();
break;
case Analysis:
AnalysePackage();
sapforTasksPackage.state = TasksPackageState.Done;
planner.UpdateSapforPackage();
break;
default:
break;
}
}
}
}

1
src/Visual_DVM_2021/Passes/All/AbortDVMPackage.java
View File

@@ -2,7 +2,6 @@ package Visual_DVM_2021.Passes.All;
import Common.Current;
import Repository.Server.ServerCode;
import Repository.Server.ServerExchangeUnit_2021;
import TestingSystem.Common.TasksPackageToKill.TasksPackageToKill;
import TestingSystem.Common.TestingPackageToKill.TestingPackageToKill;
import TestingSystem.DVM.DVMPackage.DVMPackage;
import Visual_DVM_2021.Passes.AbortTestingPackage;

41
src/Visual_DVM_2021/Passes/All/AbortSapforTaskPackage.java
View File

@@ -1,41 +0,0 @@
package Visual_DVM_2021.Passes.All;
import Common.Current;
import Repository.Server.ServerCode;
import Repository.Server.ServerExchangeUnit_2021;
import TestingSystem.Common.TasksPackageToKill.TasksPackageToKill;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import Visual_DVM_2021.Passes.Server.TestingSystemPass;
public class AbortSapforTaskPackage extends TestingSystemPass<SapforTasksPackage> {
TasksPackageToKill tasksPackageToKill = null;
@Override
public String getIconPath() {
return "/icons/Ban.PNG";
}
@Override
public String getButtonText() {
return "";
}
@Override
protected boolean canStart(Object... args) throws Exception {
tasksPackageToKill = null;
if (Current.Check(Log, Current.SapforTasksPackage)) {
target = Current.getSapforTasksPackage();
switch (target.state) {
case Done:
case Aborted:
Log.Writeln_("Пакет уже завершен.");
break;
default:
tasksPackageToKill = new TasksPackageToKill();
tasksPackageToKill.packageId = target.id;
return true;
}
}
;
return false;
}
@Override
protected void ServerAction() throws Exception {
Command(new ServerExchangeUnit_2021(ServerCode.PublishObject, Current.getAccount().email, tasksPackageToKill));
}
}

42
src/Visual_DVM_2021/Passes/All/AbortTaskPackage.java
View File

@@ -1,42 +0,0 @@
package Visual_DVM_2021.Passes.All;
import Common.Current;
import Repository.Server.ServerCode;
import Repository.Server.ServerExchangeUnit_2021;
import TestingSystem.Common.TasksPackageToKill.TasksPackageToKill;
import TestingSystem.DVM.TasksPackage.TasksPackage;
import Visual_DVM_2021.Passes.Server.TestingSystemPass;
public class AbortTaskPackage extends TestingSystemPass<TasksPackage> {
TasksPackageToKill tasksPackageToKill = null;
@Override
public String getIconPath() {
return "/icons/Ban.PNG";
}
@Override
public String getButtonText() {
return "";
}
@Override
protected boolean canStart(Object... args) throws Exception {
tasksPackageToKill = null;
if (Current.Check(Log, Current.TasksPackage)) {
target = Current.getTasksPackage();
switch (target.state) {
case Done:
case Aborted:
Log.Writeln_("Пакет уже завершен.");
break;
default:
tasksPackageToKill = new TasksPackageToKill();
tasksPackageToKill.packageId = target.id;
return true;
}
}
;
return false;
}
@Override
protected void ServerAction() throws Exception {
Command(new ServerExchangeUnit_2021(ServerCode.PublishObject, Current.getAccount().email, tasksPackageToKill));
}
}

1
src/Visual_DVM_2021/Passes/All/AddDVMPackage.java
View File

@@ -10,7 +10,6 @@ import GlobalData.Machine.MachineType;
import GlobalData.User.UserState;
import TestingSystem.DVM.DVMPackage.DVMPackage;
import TestingSystem.DVM.DVMPackage.DVMPackage_json;
import TestingSystem.DVM.TasksPackage.TasksPackage;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import Visual_DVM_2021.Passes.AddObjectPass;
import Visual_DVM_2021.Passes.PassCode_2021;

54
src/Visual_DVM_2021/Passes/All/DeleteSapforTasksPackage.java
View File

@@ -1,54 +0,0 @@
package Visual_DVM_2021.Passes.All;
import Common.Current;
import Common.Database.Database;
import Common.Global;
import Common.UI.UI;
import Common.Utils.Utils;
import TestingSystem.Common.TestingServer;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import Visual_DVM_2021.Passes.DeleteServerObjects;
import java.util.Vector;
public class DeleteSapforTasksPackage extends DeleteServerObjects<TestingServer,SapforTasksPackage> {
public DeleteSapforTasksPackage() {
super(Global.testingServer,SapforTasksPackage.class);
}
protected Database getDb() {
return server.account_db;
}
protected String getEmail() {
return Current.getAccount().email;
}
Vector<SapforTasksPackage> to_delete;
//---
public boolean checkActivity() {
to_delete = new Vector<>();
for (Object key : target) {
SapforTasksPackage tasksPackage = server.account_db.sapforTasksPackages.get(key);
if (!tasksPackage.state.equals(TasksPackageState.Done) &&
!tasksPackage.state.equals(TasksPackageState.Aborted)
) {
Log.Writeln_("Нельзя удалить активный пакет " + key + " !");
return false;
}
to_delete.add(tasksPackage);
}
return true;
}
@Override
protected boolean canStart(Object... args) throws Exception {
return super.canStart(args) && checkActivity();
}
@Override
protected void showPreparation() throws Exception {
UI.getMainWindow().getTestingWindow().DropSapforComparison();
}
@Override
protected void performDone() throws Exception {
super.performDone();
for (SapforTasksPackage tasksPackage: to_delete)
Utils.delete_with_check(tasksPackage.getLocalWorkspace());
}
}

41
src/Visual_DVM_2021/Passes/All/DeleteTasksPackage.java
View File

@@ -1,41 +0,0 @@
package Visual_DVM_2021.Passes.All;
import Common.Current;
import Common.Database.Database;
import Common.Global;
import Common.UI.UI;
import TestingSystem.Common.TestingServer;
import TestingSystem.DVM.TasksPackage.TasksPackage;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import Visual_DVM_2021.Passes.DeleteServerObjects;
public class DeleteTasksPackage extends DeleteServerObjects<TestingServer, TasksPackage> {
public DeleteTasksPackage() {
super(Global.testingServer, TasksPackage.class);
}
protected Database getDb() {
return server.account_db;
}
protected String getEmail() {
return Current.getAccount().email;
}
//---
public boolean checkActivity() {
for (Object key : target) {
TasksPackage tasksPackage = server.account_db.packages.get(key);
if (!tasksPackage.state.equals(TasksPackageState.Done) &&
!tasksPackage.state.equals(TasksPackageState.Aborted)
) {
Log.Writeln_("Нельзя удалить активный пакет " + key + " !");
return false;
}
}
return true;
}
@Override
protected boolean canStart(Object... args) throws Exception {
return super.canStart(args) && checkActivity();
}
@Override
protected void showPreparation() throws Exception {
UI.getMainWindow().getTestingWindow().DropTestRunTasksComparison();
}
}

57
src/Visual_DVM_2021/Passes/All/DownloadSapforTasksPackage.java
View File

@@ -1,57 +0,0 @@
package Visual_DVM_2021.Passes.All;
import Common.Current;
import Common.Utils.Utils;
import Repository.Server.ServerCode;
import Repository.Server.ServerExchangeUnit_2021;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import Visual_DVM_2021.Passes.PassCode_2021;
import Visual_DVM_2021.Passes.Server.TestingSystemPass;
import java.io.File;
public class DownloadSapforTasksPackage extends TestingSystemPass<SapforTasksPackage> {
@Override
public String getIconPath() {
return "/icons/DownloadBugReport.png";
}
@Override
public String getButtonText() {
return "";
}
File tmpArchive = null;
@Override
protected boolean canStart(Object... args) throws Exception {
if (args.length > 0) {
target = (SapforTasksPackage) args[0];
} else {
if (Current.Check(Log, Current.SapforTasksPackage))
target = Current.getSapforTasksPackage();
else return false;
}
//-
if (!target.state.equals(TasksPackageState.Done)) {
Log.Writeln_("Пакет не завершен.");
return false;
}
if (target.isLoaded()) {
System.out.println("Пакет уже загружен");
return false;
}
return true;
}
@Override
protected void ServerAction() throws Exception {
Command(new ServerExchangeUnit_2021(ServerCode.DownloadSapforTasksPackage, Current.getAccount().email, target.id));
response.Unpack(tmpArchive = Utils.getTempFileName(String.valueOf(target.id)));
}
@Override
protected boolean validate() {
return tmpArchive != null && tmpArchive.exists();
}
@Override
protected void performDone() throws Exception {
super.performDone();
passes.get(PassCode_2021.UnpackSapforTasksPackage).Do(tmpArchive, target);
}
}

6
src/Visual_DVM_2021/Passes/All/DownloadTaskTest.java
View File

@@ -1,13 +1,13 @@
package Visual_DVM_2021.Passes.All;
import Common.Current;
import TestingSystem.DVM.Tasks.TestRunTask;
import TestingSystem.DVM.DVMTasks.DVMRunTask;
import TestingSystem.Common.Test.Test;
public class DownloadTaskTest extends DownloadTest {
@Override
protected boolean canStart(Object... args) throws Exception {
target = null;
if (Current.getAccount().CheckRegistered(Log) && Current.Check(Log, Current.TestRunTask)) {
TestRunTask task = Current.getTestRunTask();
if (Current.getAccount().CheckRegistered(Log) && Current.Check(Log, Current.DVMRunTask)) {
DVMRunTask task = Current.getDVMRunTask();
//-- квазиобъект, нам от него нужно только имя.
target = new Test();
target.id = task.test_id;

54
src/Visual_DVM_2021/Passes/All/ExportTasksPackageToExcel.java
View File

@@ -6,8 +6,8 @@ import Common.Utils.Files.VDirectoryChooser;
import Common.Utils.Index;
import Common.Utils.Utils;
import GlobalData.Tasks.TaskState;
import TestingSystem.DVM.Tasks.TestRunTask;
import TestingSystem.DVM.TasksPackage.TasksPackage;
import TestingSystem.DVM.DVMPackage.DVMPackage;
import TestingSystem.DVM.DVMTasks.DVMRunTask;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import Visual_DVM_2021.Passes.Pass_2021;
import org.apache.commons.io.FileUtils;
@@ -22,7 +22,7 @@ import java.io.File;
import java.io.FileOutputStream;
import java.util.LinkedHashMap;
import java.util.Vector;
public class ExportTasksPackageToExcel extends Pass_2021<Vector<TasksPackage>> {
public class ExportTasksPackageToExcel extends Pass_2021<Vector<DVMPackage>> {
//https://tproger.ru/translations/how-to-read-write-excel-file-java-poi-example
File dir;
File res;
@@ -37,7 +37,7 @@ public class ExportTasksPackageToExcel extends Pass_2021<Vector<TasksPackage>> {
int total_tasks_count = 0;
long total_time = 0;
//--
LinkedHashMap<Long, Vector<TestRunTask>> packages_tasks = null;
LinkedHashMap<Integer, Vector<DVMRunTask>> packages_tasks = null;
//--
@Override
public String getIconPath() {
@@ -59,24 +59,26 @@ public class ExportTasksPackageToExcel extends Pass_2021<Vector<TasksPackage>> {
packages_tasks = new LinkedHashMap<>();
target = null;
//--
if (Global.testingServer.account_db.packages.getCheckedCount() > 0) {
target = Global.testingServer.account_db.packages.getCheckedItems();
if (Global.testingServer.db.dvmPackages.getCheckedCount() > 0) {
target = Global.testingServer.db.dvmPackages.getCheckedItems();
} else {
if (Current.Check(Log, Current.TasksPackage)) {
if (Current.Check(Log, Current.DVMPackage)) {
target = new Vector<>();
target.add(Current.getTasksPackage());
target.add(Current.getDVMPackage());
} else return false;
}
for (TasksPackage tasksPackage : target) {
if (!tasksPackage.state.equals(TasksPackageState.Done)) {
Log.Writeln_("Пакет " + tasksPackage.id + " не завершен.");
for (DVMPackage dvmPackage : target) {
if (!dvmPackage.state.equals(TasksPackageState.Done)) {
Log.Writeln_("Пакет " + dvmPackage.id + " не завершен.");
} else {
Vector<TestRunTask> tasks = new Vector<>();
for (TestRunTask task : Global.testingServer.account_db.testRunTasks.Data.values()) {
if (task.taskspackage_id == tasksPackage.id)
Vector<DVMRunTask> tasks = new Vector<>();
/* todo Загрузить и распаковать все выделенные пакеты
for (DVMRunTask task : Global.testingServer.db.testRunTasks.Data.values()) {
if (task.taskspackage_id == dvmPackage.id)
tasks.add(task);
}
packages_tasks.put(tasksPackage.id, tasks);
*/
packages_tasks.put(dvmPackage.id, tasks);
}
}
if (!Log.isEmpty())
@@ -90,14 +92,14 @@ public class ExportTasksPackageToExcel extends Pass_2021<Vector<TasksPackage>> {
return true;
}
//---
String getPackageInfo(TasksPackage object) {
String getPackageInfo(DVMPackage object) {
Vector<String> lines = new Vector<>();
lines.add("задач " + object.runTasksCount);
lines.add("задач " + object.tasksCount);
lines.add("машина " + object.machine_address + ":" + object.machine_port);
lines.add("ядер " + object.kernels);
lines.add("DVM-система " + object.dvm_version);
lines.add("DVM-система " + object.version);
//--
total_tasks_count+=object.runTasksCount;
total_tasks_count += object.tasksCount;
//--
long milliseconds = object.ChangeDate - object.StartDate;
total_time += milliseconds;
@@ -300,9 +302,9 @@ public class ExportTasksPackageToExcel extends Pass_2021<Vector<TasksPackage>> {
styles.add(style);
}
}
void exportPackageTasks(TasksPackage tasksPackage, Index offset) {
Vector<TestRunTask> tasks = packages_tasks.get(tasksPackage.id);
for (TestRunTask task : tasks) {
void exportPackageTasks(DVMPackage dvmPackage, Index offset) {
Vector<DVMRunTask> tasks = packages_tasks.get(dvmPackage.id);
for (DVMRunTask task : tasks) {
ShowMessage2(task.test_description);
//---
Integer NUM_THREADS = extractIntegerEnvironmentValue(task.environments, "DVMH_NUM_THREADS");
@@ -345,8 +347,8 @@ public class ExportTasksPackageToExcel extends Pass_2021<Vector<TasksPackage>> {
createStyles();
//--
Index offset = new Index();
for (TasksPackage tasksPackage : target) {
addInfoRow(offset.getValue(), getPackageInfo(tasksPackage));
for (DVMPackage dvmPackage : target) {
addInfoRow(offset.getValue(), getPackageInfo(dvmPackage));
offset.Inc();
}
if (target.size() > 1) {
@@ -372,8 +374,8 @@ public class ExportTasksPackageToExcel extends Pass_2021<Vector<TasksPackage>> {
"Прогресс (%)");
//--
offset.Inc();
for (TasksPackage tasksPackage : target) {
exportPackageTasks(tasksPackage, offset);
for (DVMPackage dvmPackage : target) {
exportPackageTasks(dvmPackage, offset);
}
//--
for (int i = 0; i < max_columns; ++i)

30
src/Visual_DVM_2021/Passes/All/GetTestsQueueSize.java
View File

@@ -1,30 +0,0 @@
package Visual_DVM_2021.Passes.All;
import Common.Current;
import Common.UI.UI;
import Repository.Server.ServerCode;
import Repository.Server.ServerExchangeUnit_2021;
import Visual_DVM_2021.Passes.Server.TestingSystemPass;
public class GetTestsQueueSize extends TestingSystemPass<Long> {
@Override
public String getIconPath() {
return "/icons/Help.png";
}
@Override
public String getButtonText() {
return "";
}
@Override
protected boolean canStart(Object... args) throws Exception {
return Current.Check(Log, Current.TasksPackage);
}
@Override
protected void ServerAction() throws Exception {
target = 0L;
Command(new ServerExchangeUnit_2021(ServerCode.GetQueueSize, "", Current.getTasksPackage().StartDate));
target = (long) response.object;
}
@Override
protected void showDone() throws Exception {
UI.Info("Задач в очереди: "+target);
}
}

211
src/Visual_DVM_2021/Passes/All/StartSapforTests.java
View File

@@ -1,211 +0,0 @@
package Visual_DVM_2021.Passes.All;
import Common.Constants;
import Common.Current;
import Common.Global;
import Common.UI.UI;
import Common.Utils.Index;
import ProjectData.LanguageName;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.Test.Test;
import TestingSystem.DVM.TasksPackage.TasksPackageState;
import TestingSystem.SAPFOR.SapforConfiguration.SapforConfiguration;
import TestingSystem.SAPFOR.SapforConfigurationCommand.SapforConfigurationCommand;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import Visual_DVM_2021.Passes.PassCode_2021;
import Visual_DVM_2021.Passes.Server.PublishServerAccountObject;
import java.io.File;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Vector;
public class StartSapforTests extends PublishServerAccountObject<SapforTasksPackage> {
protected int allTasksCount = 0;
protected LinkedHashMap<Integer, Vector<Integer>> groupsTests = null;
protected LinkedHashMap<String, Test> testsByDescriptions = null;
protected Vector<String> testsNames_lower = null; //все тесты что участвуют здесь
protected Vector<LanguageName> groupsLanguages = null;
protected Vector<String> testsIds = null;
protected Vector<String> configurationsIds = null;
protected File sapfor = null;
//--
public StartSapforTests() {
super(SapforTasksPackage.class);
}
//---
@Override
public String getIconPath() {
return "/icons/Start.png";
}
//--
protected boolean checkTestName(Test test) {
String name = test.description.toLowerCase();
if (testsNames_lower.contains(name)) {
Log.Writeln_("В пакет не могут входить тесты с одинаковыми именами (без учета регистра):" + test.description.toLowerCase());
return false;
}
testsNames_lower.add(name);
return true;
}
protected boolean getGroupTests(int groupId) {
Vector<Integer> groupTests = new Vector<>();
Vector<Integer> selectedGroupTests = new Vector<>();
//---
for (Test test : server.db.tests.Data.values()) {
if (test.group_id==groupId) {
groupTests.add(test.id);
if (test.isSelected())
selectedGroupTests.add(test.id);
}
}
if (!groupTests.isEmpty() && !selectedGroupTests.isEmpty())
groupTests = selectedGroupTests;
//---
if (groupTests.isEmpty()) {
Log.Writeln_("Пустая группа тестов: " + groupId);
return false;
}
//--
for (int testId : groupTests) {
Test test = Global.testingServer.db.tests.get(testId);
if (!checkTestName(test))
return false;
else
testsByDescriptions.put(test.description, test);
}
//--
groupsTests.put(groupId, groupTests);
//--
return true;
}
boolean checkTerminalCode(SapforConfiguration sapforConfiguration, PassCode_2021 code, int count, Vector<PassCode_2021> codes) {
if (count > 2) {
Log.Writeln_("Неверная конфигурация:" + sapforConfiguration.id + ": " +
code.getDescription() +
" возможно только один раз.");
return false;
}
//--
if ((count == 1) && codes.size() > 1) {
if (!codes.lastElement().equals(code)) {
Log.Writeln_("Неверная конфигурация:" + sapforConfiguration.id + ": " +
code.getDescription() +
" может быть только завершающей командой!");
return false;
}
}
return true;
}
public boolean getConfigurationCommands(SapforConfiguration sapforConfiguration) {
//1. получить список всех команд.
Vector<PassCode_2021> codes = new Vector<>();
//-- счетчик завершающих команд.
LinkedHashMap<PassCode_2021, Index> terminalCodesCount = new LinkedHashMap<>();
for (PassCode_2021 code : Constants.terminalSapforTestingCodes)
terminalCodesCount.put(code, new Index());
//--
for (SapforConfigurationCommand command : Global.testingServer.db.sapforConfigurationCommands.Data.values()) {
if (command.sapforconfiguration_id==sapforConfiguration.id) {
codes.add(command.passCode);
//---
for (PassCode_2021 t_code : Constants.terminalSapforTestingCodes) {
if (command.passCode.equals(t_code))
terminalCodesCount.get(t_code).Inc();
}
//---
}
}
//--
if (codes.size() == 0) {
Log.Writeln_("Пустая конфигурация:" + sapforConfiguration.id);
return false;
}
for (PassCode_2021 t_code : Constants.terminalSapforTestingCodes) {
if (!checkTerminalCode(sapforConfiguration, t_code,
terminalCodesCount.get(t_code).getValue(), codes
))
return false;
}
//--
return true;
}
//--
@Override
public boolean fillObjectFields() throws Exception {
//--
allTasksCount = 0;
groupsTests = new LinkedHashMap<>();
testsNames_lower = new Vector<>();
testsByDescriptions = new LinkedHashMap<>();
groupsLanguages = new Vector<>();
testsIds =new Vector<>();
configurationsIds = new Vector<>();
//-->>
if (!Current.getAccount().CheckRegistered(Log)) {
return false;
}
//проверка стартовых условий.
if (!Current.Check(Log, Current.ServerSapfor))
return false;
//--->>
if (Global.testingServer.db.sapforConfigurations.getCheckedCount() == 0) {
Log.Writeln_("Не отмечено ни одной конфигурации SAPFOR.");
return false;
}
//-
for (SapforConfiguration configuration : Global.testingServer.db.sapforConfigurations.getCheckedItems()) {
if (!getConfigurationCommands(configuration))
return false;
}
//--
if (Global.testingServer.db.groups.getCheckedCount() == 0) {
Log.Writeln_("Не отмечено ни одной группы тестов");
return false;
}
//--
for (Group group : Global.testingServer.db.groups.getCheckedItems()) {
//---
if (!groupsLanguages.contains(group.language))
groupsLanguages.add(group.language);
//-
if (groupsLanguages.get(0) != LanguageName.fortran) {
Log.Writeln_("Поддерживается пакетный режим только для языка Fortran!");
return false;
}
if (groupsLanguages.size() > 1) {
Log.Writeln_("Запуск тестов на разных языках в рамках одного пакета запрещен!");
return false;
}
//---
if (!getGroupTests(group.id))
return false;
}
//--
for (int i = 0; i < Global.testingServer.db.sapforConfigurations.getCheckedCount(); ++i) {
for (Vector<Integer> tests : groupsTests.values())
allTasksCount += tests.size();
}
//--
for (Test test : testsByDescriptions.values())
testsIds.add(String.valueOf(test.id));
//--
for (SapforConfiguration configuration : Global.testingServer.db.sapforConfigurations.getCheckedItems())
configurationsIds.add(String.valueOf(configuration.id));
//--
target.tasksCount = allTasksCount;
target.testsIds = String.join("\n", testsIds);
target.configurationsIds = String.join("\n", configurationsIds);
//--
target.sapforId = Current.getServerSapfor().id;
target.sapfor_version = Current.getServerSapfor().version;
//--
target.testsNames = String.join(";", testsNames_lower);
target.StartDate = new Date().getTime();
target.kernels = Global.properties.TestingKernels;
target.state = TasksPackageState.Queued;
target.needsEmail = Global.properties.EmailOnTestingProgress ? 1 : 0;
//---
return (UI.Question("Будет запущено:\n"
+ allTasksCount + " задач\n" +
"Продолжить"));
}
}

221
src/Visual_DVM_2021/Passes/All/StartTests.java
View File

@@ -1,221 +0,0 @@
package Visual_DVM_2021.Passes.All;
import Common.Current;
import Common.Global;
import Common.UI.UI;
import Common.Utils.Utils;
import GlobalData.Compiler.CompilerType;
import GlobalData.Machine.MachineType;
import GlobalData.User.UserState;
import TestingSystem.Common.Group.Group;
import TestingSystem.Common.Test.Test;
import TestingSystem.DVM.Tasks.TestCompilationTask;
import TestingSystem.DVM.Tasks.TestRunTask;
import TestingSystem.DVM.TasksPackage.TasksPackage;
import Visual_DVM_2021.Passes.PassCode_2021;
import Visual_DVM_2021.Passes.Server.PublishServerAccountObject;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Vector;
public class StartTests extends PublishServerAccountObject<TasksPackage> {
public StartTests() {
super(TasksPackage.class);
}
@Override
protected int getTimeout() {
return 0;
}
@Override
public String getIconPath() {
return "/icons/Start.png";
}
@Override
protected boolean canStart(Object... args) throws Exception {
if (!Current.getAccount().CheckRegistered(Log)) {
return false;
}
if (Current.Check(Log, Current.Machine, Current.User, Current.Compiler)) {
if (!Current.getMachine().type.equals(MachineType.Server)) {
Log.Writeln_("Тестирование поддерживается только на одиночном удалённом сервере.");
return false;
}
if (!Current.getUser().state.equals(UserState.ready_to_work)) {
Log.Writeln_("Пользователь не готов к работе. Выполните инициализацию пользователя!");
return false;
}
if (!Current.getCompiler().type.equals(CompilerType.dvm)) {
Log.Writeln_("Тестирование поддерживается только для DVM компиляторов.");
return false;
}
if (!Current.getCompiler().versionLoaded)
passes.get(PassCode_2021.ShowCompilerVersion).Do(Current.getCompiler(), false);
if (!CreateTasks()) {
Log.Writeln_("Не удалось создать задачи.\n" +
"Для создания задач отметьте требуемые конфигурации,\n" +
"Отметьте группы, или отдельные тесты в отмеченной текущей группе");
return false;
}
//-
if (target.runTasksCount == 0) {
Log.Writeln_("Не будет создано ни одной задачи на запуск.");
return false;
}
//todo сюда же флаг нужно ли почтовое отправление.
if (UI.Question("Будет запущено:\n"
+ target.compilationTasksCount + " задач на компиляцию\n" +
+target.runTasksCount + " задач на запуск.\n" +
"Продолжить")) {
return true;
}
}
return false;
}
public static String checkFlags(String flags_in) {
if (!flags_in.contains("-shared-dvm")) {
if (flags_in.isEmpty())
return "-shared-dvm";
else return flags_in + " -shared-dvm";
} else
return flags_in;
}
public static String checkEnvironments(String environmentsSet_in) {
if (!environmentsSet_in.contains("DVMH_NO_DIRECT_COPY")) {
if (environmentsSet_in.isEmpty())
return "DVMH_NO_DIRECT_COPY=" + Utils.DQuotes("1");
else
return environmentsSet_in + " " + "DVMH_NO_DIRECT_COPY=" + Utils.DQuotes("1");
} else
return environmentsSet_in;
}
public static Vector<TestCompilationTask> createTasksCGT(
TestingSystem.DVM.Configuration.Configuration configuration,
Group group,
Test test
) {
Vector<TestCompilationTask> compilationTasks = new Vector<>();
for (String flags : configuration.getFlags()) {
String checked_flags = checkFlags(flags);
TestCompilationTask testCompilationTask = new TestCompilationTask(
configuration,
group,
test,
checked_flags
);
testCompilationTask.runTasks = new Vector<>();
Vector<String> matrixes = configuration.getMatrixes(test.max_dim);
Vector<String> environments = configuration.getEnvironments();
for (String environmentSet : environments) {
String checkedEnvironments = checkEnvironments(environmentSet);
if (flags.trim().equalsIgnoreCase("-s")) {
testCompilationTask.runTasks.add(new TestRunTask(
configuration,
group,
test,
"",
checked_flags,
checkedEnvironments,
configuration.getParamsText()
));
} else
for (String matrix : matrixes) {
testCompilationTask.runTasks.add(new TestRunTask(
configuration,
group,
test,
matrix,
checked_flags,
checkedEnvironments,
configuration.getParamsText()));
}
}
compilationTasks.add(testCompilationTask);
}
return compilationTasks;
}
protected boolean CreateTasks() {
//---------
Vector<String> configurations_lines = new Vector<>();
Vector<String> groups_lines = new Vector<>();
//-----------
target = new TasksPackage();
target.StartDate = new Date().getTime();
//-
target.machine_name = Current.getMachine().name;
target.machine_address = Current.getMachine().address;
target.machine_port = Current.getMachine().port;
target.machine_type = Current.getMachine().type;
//-
target.user_name = Current.getUser().login;
target.user_password = Current.getUser().password;
target.user_workspace = Current.getUser().workspace;
target.dvm_drv = Current.getCompiler().call_command;
target.dvm_version = Current.getCompiler().getVersionInfo();
target.kernels = Global.properties.TestingKernels;
Vector<TestCompilationTask> tasks = new Vector<>();
//1, Проверяем выбраны ли конфиги.
if (server.db.configurations.getCheckedCount() == 0) {
Log.Writeln_("Не отмечена ни одна конфигурация тестирования.");
return false;
}
if (server.db.groups.getCheckedCount() > 0) {
//2 Проверяем выбраны ли группы.
configurations_lines.add("Конфигурации: ");
for (TestingSystem.DVM.Configuration.Configuration configuration : server.db.configurations.getCheckedItems()) {
configurations_lines.add(configuration.getSummary());
groups_lines.add("Группы: ");
for (Group group : server.db.groups.getCheckedItems()) {
groups_lines.add(group.getSummary());
Vector<Test> groupTests = new Vector<>();
Vector<Test> checkedGroupTests = new Vector<>();
for (Test test : server.db.tests.Data.values()) {
if (test.group_id == group.id) {
groupTests.add(test);
if (test.isSelected())
checkedGroupTests.add(test);
}
}
if (!groupTests.isEmpty()) {
if (checkedGroupTests.isEmpty()) {
for (Test test : groupTests)
tasks.addAll(createTasksCGT(configuration, group, test));
} else {
//добавляем только отмеченные.
for (Test test : checkedGroupTests) {
tasks.addAll(createTasksCGT(configuration, group, test));
}
}
}
}
}
}
//рассортировать по группам и тестам задачи.
for (TestCompilationTask task : tasks) {
target.compilationTasksCount++;
target.runTasksCount += task.runTasks.size();
LinkedHashMap<Integer, Vector<TestCompilationTask>> group_tasks = null;
if (target.sorted_tasks.containsKey(task.group_id))
group_tasks = target.sorted_tasks.get(task.group_id);
else {
group_tasks = new LinkedHashMap<>();
target.sorted_tasks.put(task.group_id, group_tasks);
}
Vector<TestCompilationTask> test_tasks = null;
if (group_tasks.containsKey(task.test_id))
test_tasks = group_tasks.get((task.test_id));
else {
test_tasks = new Vector<>();
group_tasks.put(task.test_id, test_tasks);
}
test_tasks.add(task);
}
Vector<String> summary_lines = new Vector<>();
summary_lines.addAll(configurations_lines);
summary_lines.addAll(groups_lines);
target.summary =
"Задач на компиляцию: " + target.compilationTasksCount + "\n" +
"Задач на запуск: " + target.runTasksCount + "\n" +
String.join("\n", summary_lines);
target.needsEmail = Global.properties.EmailOnTestingProgress ? 1 : 0;
return !tasks.isEmpty();
}
}

95
src/Visual_DVM_2021/Passes/All/SynchronizeTestsTasks.java
View File

@@ -1,95 +0,0 @@
package Visual_DVM_2021.Passes.All;
import Common.Current;
import Common.Global;
import Common.UI.UI;
import Common.Utils.Utils;
import Repository.Server.ServerCode;
import Repository.Server.ServerExchangeUnit_2021;
import TestingSystem.Common.TestingServer;
import Visual_DVM_2021.Passes.Pass_2021;
import Visual_DVM_2021.Passes.Server.TestingSystemPass;
import org.apache.commons.io.FileUtils;
import java.io.File;
public class SynchronizeTestsTasks extends Pass_2021 {
byte[] db_file_bytes;
File new_db_file;
@Override
protected boolean canStart(Object... args) throws Exception {
db_file_bytes = null;
new_db_file = null;
if (Current.getAccount().CheckRegistered(Log)) {
TestingSystemPass download = new TestingSystemPass() {
@Override
protected boolean needsAnimation() {
return false;
}
@Override
public String getDescription() {
return "Загрузка базы тестовых задач";
}
@Override
protected void ServerAction() throws Exception {
Command(new ServerExchangeUnit_2021(ServerCode.ReceiveTestsTasksDatabase, Current.getAccount().email));
db_file_bytes = (byte[]) response.object;
}
};
return download.Do();
}
return false;
}
@Override
protected boolean needsAnimation() {
return false;
}
@Override
public String getIconPath() {
return "/icons/ComponentsActual.png";
}
@Override
public String getButtonText() {
return "";
}
@Override
protected void performPreparation() throws Exception {
Global.testingServer.account_db.Disconnect();
}
@Override
protected void showPreparation() throws Exception {
Global.testingServer.account_db.SaveLastSelections();
Global.testingServer.account_db.packages.ClearUI();
Global.testingServer.account_db.sapforTasksPackages.ClearUI();
}
@Override
protected void body() throws Exception {
Utils.unpackFile(db_file_bytes, new_db_file = Utils.getTempFileName("tdb"));
if (new_db_file.exists()) {
Utils.forceDeleteWithCheck(Global.testingServer.account_db.getFile());
FileUtils.moveFile(new_db_file, Global.testingServer.account_db.getFile());
Global.testingServer.account_db.setFile(Current.getAccount().email);
}
//--
Global.testingServer.account_db.Connect();
Global.testingServer.account_db.CreateAllTables();
Global.testingServer.account_db.prepareTablesStatements();
Global.testingServer.account_db.Synchronize();
UI.getMainWindow().getTestingWindow().RemountTestTable();
//--
}
@Override
protected boolean validate() {
return (db_file_bytes != null);
}
@Override
protected void showFinish() throws Exception {
Global.testingServer.account_db.packages.ShowUI();
Global.testingServer.account_db.sapforTasksPackages.ShowUI();
Global.testingServer.account_db.RestoreLastSelections();
if (!Global.testingServer.account_db.hasActivePackages()) {
Global.properties.updateField("AutoCheckTesting", false);
TestingServer.TimerOff();
UI.testingBar.ShowAutoCheckTesting();
}
}
}

31
src/Visual_DVM_2021/Passes/All/UnpackSapforTasksPackage.java
View File

@@ -1,31 +0,0 @@
package Visual_DVM_2021.Passes.All;
import Common.Global;
import Common.Utils.Utils;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.util.Date;
public class UnpackSapforTasksPackage extends UnzipFolderPass<SapforTasksPackage> {
@Override
protected boolean needsAnimation() {
return true;
}
@Override
protected boolean canStart(Object... args) {
File tmpArchive = (File) args[0];
target = (SapforTasksPackage) args[1];
return super.canStart(tmpArchive.getAbsolutePath(),Global.SapforPackagesDirectory.getAbsolutePath(), false);
}
@Override
protected void performPreparation() throws Exception {
super.performPreparation();
File packageWorkspace = target.getLocalWorkspace();
Utils.forceDeleteWithCheck(packageWorkspace);
}
@Override
protected void body() throws Exception {
super.body();
FileUtils.writeStringToFile(target.getLoadedSign(), new Date().toString());
}
}

33
src/Visual_DVM_2021/Passes/PassCode_2021.java
View File

@@ -5,20 +5,14 @@ public enum PassCode_2021 {
UpdateProperty,
ShowAllParallelVariants,
ShowParallelVariantsCoverage,
AbortSapforTaskPackage,
UnpackSapforTasksPackage,
//-
DeleteServerSapfor,
StartSapforTests,
InstallServerSapfor,
SaveProfile,
ApplyProfile,
EditProfile,
DeleteProfile,
//-
DeleteSapforTasksPackage,
//-
//-
CheckAccount,
CheckRegistrationOnServer,
EditAccount,
@@ -235,7 +229,6 @@ public enum PassCode_2021 {
EditDVMParameter,
DeleteDVMParameter,
//-
SynchronizeTestsTasks,
SPF_GetArrayLinks,
Precompilation,
GCOV,
@@ -252,11 +245,8 @@ public enum PassCode_2021 {
PublishConfiguration,
EditConfiguration,
//-
StartTests,
//-
DownloadTaskTest,
//-
GetTestsQueueSize,
ApplyCurrentFunction,
//->
CheckRemoteWorkspace,
@@ -286,13 +276,11 @@ public enum PassCode_2021 {
EditSapforConfigurationCommand,
DeleteSapforConfigurationCommand,
//->
DownloadSapforTasksPackage,
OpenSapforEtalonVersion,
OpenSapforVersion,
PublishServerSapfor,
DeleteTest,
DeleteConfiguration,
AbortTaskPackage,
//--
CreateGroupFromDirectory,
CreateTestFromDirectory,
@@ -301,7 +289,6 @@ public enum PassCode_2021 {
CreateTestFromFile,
CreateTestsFromFiles,
CreateGroupFromFiles,
DeleteTasksPackage,
DeleteSubscriberWorkspace,
ExportTasksPackageToExcel,
//->
@@ -356,8 +343,6 @@ public enum PassCode_2021 {
return "Экспорт пакета задач в Excel";
case DeleteSubscriberWorkspace:
return "Удалить рабочее пространство пользователя";
case DeleteTasksPackage:
return "Удалить пакет задач";
case CreateGroupFromFiles:
return "Создать группу из файлов в папке";
case CreateTestsFromFiles:
@@ -374,8 +359,6 @@ public enum PassCode_2021 {
return "Удаление Open MP директив";
case CreateGroupFromDirectory:
return "Создать группу тестов из папки";
case AbortTaskPackage:
return "Прерывать пакет тестирования DVM";
case DeleteConfiguration:
return "Удалить конфигурацию";
case DeleteTest:
@@ -390,22 +373,12 @@ public enum PassCode_2021 {
return "Открыть текущую эталонную версию SAPFOR как проект";
case OpenSapforVersion:
return "Открыть текущую версию SAPFOR как проект";
case UnpackSapforTasksPackage:
return "Распаковка пакета задач SAPFOR";
case DownloadSapforTasksPackage:
return "Загрузить пакет задач SAPFOR";
case AbortSapforTaskPackage:
return "Прервать пакет задач SAPFOR";
case ShowAllParallelVariants:
return "Отобразить все параллельные варианты";
case ShowParallelVariantsCoverage:
return "Отобразить минимальное покрытие параллельных вариантов";
case DeleteSapforTasksPackage:
return "Удалить пакет задач SAPFOR";
case DeleteServerSapfor:
return "Удалить версию SAPFOR";
case StartSapforTests:
return "Запустить тестирование на сервере";
case InstallServerSapfor:
return "Собрать актуальную версию SAPFOR";
case EditProfile:
@@ -492,12 +465,8 @@ public enum PassCode_2021 {
return "Публикация удалённой рабочей папки";
case ApplyCurrentFunction:
return "Назначить текущую функцию по имени";
case GetTestsQueueSize:
return "Очередь перед текущим пакетом";
case DownloadTaskTest:
return "Загрузить тест текущей задачи";
case StartTests:
return "Запуск тестов";
case PublishConfiguration:
return "Опубликовать конфигурацию тестирования";
case EditConfiguration:
@@ -524,8 +493,6 @@ public enum PassCode_2021 {
return "Предварительная компиляция на локальной машине";
case SPF_GetArrayLinks:
return "Получить связи между массивами";
case SynchronizeTestsTasks:
return "Синхронизация базы данных тестовых задач.";
case SaveBugReportExecutor:
return "Назначить исполнителя отчёта об ошибке";
case SaveBugReportRecipients:

23
src/Visual_DVM_2021/Passes/Server/DeleteServerAccountObject.java
View File

@@ -1,23 +0,0 @@
package Visual_DVM_2021.Passes.Server;
import Common.Current;
import Common.Database.DBObject;
import Common.Database.Database;
import Common.Global;
import Repository.Server.ServerCode;
import Repository.Server.ServerExchangeUnit_2021;
import TestingSystem.Common.TestingServer;
import javafx.util.Pair;
public class DeleteServerAccountObject<D extends DBObject> extends DeleteServerObject<TestingServer, D> {
public DeleteServerAccountObject(Class<D> d_in) {
super(Global.testingServer, d_in);
}
@Override
protected Database getDb() {
return Global.testingServer.account_db;
}
@Override
protected void ServerAction() throws Exception {
Command(new ServerExchangeUnit_2021(ServerCode.DeleteAccountObjectByPK, Current.getAccount().email,
new Pair<>(target.getClass(), target.getPK())));
}
}

19
src/Visual_DVM_2021/Passes/Server/PublishServerAccountObject.java
View File

@@ -1,19 +0,0 @@
package Visual_DVM_2021.Passes.Server;
import Common.Current;
import Common.Database.DBObject;
import Common.Database.Database;
import Common.Global;
import TestingSystem.Common.TestingServer;
public class PublishServerAccountObject<D extends DBObject> extends PublishServerObject<TestingServer, D> {
public PublishServerAccountObject(Class<D> d_in) {
super(Global.testingServer, d_in);
}
@Override
protected Database getDb() {
return Global.testingServer.account_db;
}
@Override
protected String getEmail() {
return Current.getAccount().email;
}
}

1
src/Visual_DVM_2021/UI/Interface/TestingWindow.java
View File

@@ -9,7 +9,6 @@ public interface TestingWindow extends VisualizerForm {
void ShowNoTestRunTask();
//-
void RefreshTabsNames();
void RemountTestTable();
//-
void FocusTestingTasks();
void ShowCurrentSapforPackageVersionEtalon();

29
src/Visual_DVM_2021/UI/Main/DVMRunTasksComparisonForm.java Normal file
View File

@@ -0,0 +1,29 @@
package Visual_DVM_2021.UI.Main;
import Common.Current;
import TestingSystem.DVM.DVMTasks.DVMRunTask;
public class DVMRunTasksComparisonForm extends TasksComparisonForm<DVMRunTask> {
public DVMRunTasksComparisonForm(ComparisonForm<DVMRunTask> slave_in) {
super(DVMRunTask.class, slave_in);
}
@Override
protected Current getCurrentObjectName() {
return Current.DVMRunTask;
}
@Override
protected String getTextByTab() {
switch (status) {
case CompilationOutput:
return object.getCompilationOutput();
case CompilationErrors:
return object.getCompilationErrors();
case RunOutput:
return object.getOutput();
case RunErrors:
return object.getErrors();
case Sts:
return object.getStatistic();
default:
return "";
}
}
}

31
src/Visual_DVM_2021/UI/Main/SapforPackagesComparisonForm.java
View File

@@ -4,8 +4,8 @@ import Common.UI.Label.ShortLabel;
import Common.UI.Menus_2023.VisualiserMenuBar;
import Common.UI.UI;
import Common.Utils.TextLog;
import TestingSystem.SAPFOR.SapforPackage.SapforPackage;
import TestingSystem.SAPFOR.SapforTask.SapforTask;
import TestingSystem.SAPFOR.SapforTasksPackage.SapforTasksPackage;
import TestingSystem.SAPFOR.SapforTasksPackage.UI.SapforTasksPackageTree;
import Visual_DVM_2021.Passes.PassCode_2021;
import Visual_DVM_2021.Passes.Pass_2021;
@@ -31,7 +31,7 @@ public class SapforPackagesComparisonForm {
SapforPackagesComparisonForm slave = null;
SapforPackagesComparisonForm master = null;
//-->>
protected SapforTasksPackage object = null;
protected SapforPackage object = null;
//-->>
// protected DataSet<String, SapforTaskResult> packageTasks;
protected SapforTasksPackageTree Body;
@@ -63,17 +63,19 @@ public class SapforPackagesComparisonForm {
}
}
public void ApplyObject() {
/*
//---
RemoveObject();
//---
TextLog log = new TextLog();
if (Current.Check(log, Current.SapforTasksPackage)) {
object = Current.getSapforTasksPackage();
if (object.isLoaded() || (Pass_2021.passes.get(PassCode_2021.DownloadSapforTasksPackage).Do(object))) {
if (Current.Check(log, Current.SapforPackage)) {
object = Current.getSapforPackage();
if (object.isLoaded() || (Pass_2021.passes.get(PassCode_2021.DownloadSapforPackage).Do(object))) {
showObject();
}
} else
UI.Info(log.toString());
*/
}
public void Show() throws Exception {
}
@@ -89,6 +91,7 @@ public class SapforPackagesComparisonForm {
}
//---
public void showCommonTree() {
/*
//---
treePanel.add(treeScroll = new JScrollPane(
Body = new SapforTasksPackageTree(object.results.root,
@@ -96,20 +99,25 @@ public class SapforPackagesComparisonForm {
)));
treePanel.repaint();
treePanel.revalidate();
*/
}
public void showComparisonTree() {
/*
treePanel.add(treeScroll = new JScrollPane(
Body = new SapforTasksPackageTree(object.results.comparison_root,
isMaster() ? Current.SapforEtalonVersion : Current.SapforVersion
)));
treePanel.repaint();
treePanel.revalidate();
*/
}
//---
public void showNoTree() {
UI.Clear(treePanel);
}
public void showObject() {
/*
lObjectName.setText(object.getPK().toString() + (isMaster() ? "(эталон)" : ""));
lObjectName.setToolTipText(object.getPK().toString());
//--
@@ -117,6 +125,7 @@ public class SapforPackagesComparisonForm {
object.readResults();
//--
showCommonTree();
*/
}
protected String getText() {
return "";
@@ -164,8 +173,8 @@ public class SapforPackagesComparisonForm {
}
public void DoComparePass() {
Pass_2021 pass = new Pass_2021() {
SapforTasksPackage package1;
SapforTasksPackage package2;
SapforPackage package1;
SapforPackage package2;
@Override
public String getDescription() {
return "Сравнение";
@@ -193,11 +202,13 @@ public class SapforPackagesComparisonForm {
Log.Writeln_("Наборы конфигураций не совпадают!");
return false;
}
/*
for (String key1 : package1.results.allTasks.keySet()) {
if (!package2.results.allTasks.containsKey(key1)) {
Log.Writeln_("Задача эталона " + key1 + "не найдена в сравниваемом пакете!");
}
}
*/
return Log.isEmpty();
}
return false;
@@ -210,8 +221,8 @@ public class SapforPackagesComparisonForm {
treeScroll = null;
slave.treeScroll = null;
//--
package1.results.DropComparison();
package2.results.DropComparison();
// package1.results.DropComparison();
// package2.results.DropComparison();
}
@Override
protected void showPreparation() throws Exception {
@@ -223,6 +234,7 @@ public class SapforPackagesComparisonForm {
}
@Override
protected void body() throws Exception {
/*
System.out.println(package1.results.allTasks.size());
System.out.println(package2.results.allTasks.size());
//теперь сравниваем задачи
@@ -242,6 +254,7 @@ public class SapforPackagesComparisonForm {
//-
package1.results.buildComparisonTree(package1);
package2.results.buildComparisonTree(package2);
*/
}
@Override
protected boolean validate() {

29
src/Visual_DVM_2021/UI/Main/TestRunTasksComparisonForm.java
View File

@@ -1,29 +0,0 @@
package Visual_DVM_2021.UI.Main;
import Common.Current;
import TestingSystem.DVM.Tasks.TestRunTask;
public class TestRunTasksComparisonForm extends TasksComparisonForm<TestRunTask> {
public TestRunTasksComparisonForm(ComparisonForm<TestRunTask> slave_in) {
super(TestRunTask.class, slave_in);
}
@Override
protected Current getCurrentObjectName() {
return Current.TestRunTask;
}
@Override
protected String getTextByTab() {
switch (status) {
case CompilationOutput:
return object.compilation_output;
case CompilationErrors:
return object.compilation_errors;
case RunOutput:
return object.output;
case RunErrors:
return object.errors;
case Sts:
return object.statistic;
default:
return "";
}
}
}

19
src/Visual_DVM_2021/UI/Main/TestingForm.form
View File

@@ -281,25 +281,6 @@
</grid>
</children>
</grid>
<grid id="68338" layout-manager="BorderLayout" hgap="0" vgap="0">
<constraints>
<tabbedpane title="" icon="icons/MassFiles.png">
<tooltip value="Список задач"/>
</tabbedpane>
</constraints>
<properties>
<enabled value="true"/>
</properties>
<border type="none"/>
<children>
<grid id="1beb4" binding="sapforTasksPanel" layout-manager="BorderLayout" hgap="0" vgap="0">
<constraints border-constraint="Center"/>
<properties/>
<border type="none"/>
<children/>
</grid>
</children>
</grid>
</children>
</tabbedpane>
</children>

20
src/Visual_DVM_2021/UI/Main/TestingForm.java
View File

@@ -48,14 +48,13 @@ public class TestingForm implements FormWithSplitters, TestingWindow {
private JPanel serverSapforsPanel;
private JPanel sapforPackagesPanel;
private JTabbedPane sapforPackageTabs;
private JPanel sapforTasksPanel;
private JPanel testsRunTasksBackground;
private JCheckBox filterFinished;
private JButton bTest;
private JButton bDownloadTestProject;
//-
private final TestRunTasksComparisonForm dvmTestingRunMaster; //сравнение тестов двм системы.
private final TestRunTasksComparisonForm dvmTestingRunSlave;
private final DVMRunTasksComparisonForm dvmTestingRunMaster; //сравнение тестов двм системы.
private final DVMRunTasksComparisonForm dvmTestingRunSlave;
//-
private final SapforPackagesComparisonForm sapforPackageTreeMaster; //сравнение деревьев пакетов SAPFOR.
private final SapforPackagesComparisonForm sapforPackageTreeSlave;
@@ -67,7 +66,7 @@ public class TestingForm implements FormWithSplitters, TestingWindow {
content.add(UI.testingBar, BorderLayout.NORTH);
LoadSplitters();
//-
dvmTestingRunMaster = new TestRunTasksComparisonForm(dvmTestingRunSlave = new TestRunTasksComparisonForm(null));
dvmTestingRunMaster = new DVMRunTasksComparisonForm(dvmTestingRunSlave = new DVMRunTasksComparisonForm(null));
sapforPackageTreeMaster = new SapforPackagesComparisonForm(sapforPackageTreeSlave = new SapforPackagesComparisonForm(null));
sapforVersionMaster = new SapforVersionsComparisonForm(
sapforVersionSlave = new SapforVersionsComparisonForm(null, Current.SapforVersion),
@@ -162,19 +161,6 @@ public class TestingForm implements FormWithSplitters, TestingWindow {
sapforVersionSlave.RemoveObject();
}
@Override
public void RemountTestTable() {
UI.Clear(dvmPackagesPanel);
UI.Clear(dvmRunTasksPanel);
UI.Clear(sapforPackagesPanel);
UI.Clear(sapforTasksPanel);
DropSapforComparison();
//-->>
Global.testingServer.account_db.packages.mountUI(dvmPackagesPanel);
Global.testingServer.account_db.testRunTasks.mountUI(dvmRunTasksPanel);
Global.testingServer.account_db.sapforTasksPackages.mountUI(sapforPackagesPanel);
Global.testingServer.account_db.sapforTasks.mountUI(sapforTasksPanel);
}
@Override
public void FocusSapforTesting() {
testingTabs.setSelectedIndex(1);
}