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

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);
}
}
}

436
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;
@@ -836,14 +422,14 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
}
response.object = res_;
}
private void DownloadDVMPackage() throws Exception{
private void DownloadDVMPackage() throws Exception {
int dvmPackage_id = (int) request.object;
if (!db.dvmPackages.containsKey(dvmPackage_id))
throw new RepositoryRefuseException("Не найдено пакета тестирования DVM с ключом "+dvmPackage_id);
throw new RepositoryRefuseException("Не найдено пакета тестирования DVM с ключом " + dvmPackage_id);
response = new ServerExchangeUnit_2021(ServerCode.OK);
DVMPackage dvmPackage = db.dvmPackages.get(dvmPackage_id);
File workspace = dvmPackage.getLocalWorkspace();
File results_zip = new File (workspace, "results.zip");
File results_zip = new File(workspace, "results.zip");
File package_json = dvmPackage.getJsonFile();
response.object = new Pair(Utils.packFile(results_zip), Utils.packFile(package_json));
}

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 "?";
}
}
//--

23
src/TestingSystem/DVM/DVMTasks/DVMRunTasksBar.java Normal file
View File

@@ -0,0 +1,23 @@
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 DVMRunTasksBar extends DataMenuBar {
JMenuBar filters= null;
public void DropFilters() {
if (filters != null) {
remove(filters);
filters = null;
}
revalidate();
repaint();
}
public void addFilters(JMenu cFilterMenu, JMenu rFilterMenu) {
filters= addMenus(cFilterMenu, rFilterMenu);
}
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<TestRunTask>> compilationFilters;
public Vector<TableFilter<TestRunTask>> runFilters;
public TestRunTasksDBTable() {
super(Long.class, TestRunTask.class);
//--
public Vector<TableFilter<DVMRunTask>> compilationFilters;
public Vector<TableFilter<DVMRunTask>> runFilters;
DVMPackage target;
public DVMRunTasksSet() {
super(Integer.class, DVMRunTask.class);
//todo обобщить бы наличие фильтров для всех таблиц.
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) {
@@ -76,7 +76,41 @@ public class TestRunTasksDBTable extends DBTable<Long, TestRunTask> {
run |= true;
}
}
return compilation&&run;
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() {
@@ -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;
}
@Override
public void ShowUI() {
ResetFiltersCount();
super.ShowUI();
ShowFiltersCount();
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();
}
}
@Override
public void ShowUI(Object key) {
ResetFiltersCount();
super.ShowUI(key);
ShowFiltersCount();
public void ShowNoPackage() {
ClearUI();
Data.clear();
if (target != null) {
target.destructor();
target = null;
}
}
}

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;
}
}
}
}