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;