package _VisualDVM.TestingSystem.Common; import Common.CommonConstants; import Common.Database.SQLITE.SQLiteDatabase; import Common.Utils.Utils_; import _VisualDVM.ComponentsServer.Component.Sapfor.Sapfor; import _VisualDVM.ComponentsServer.UserAccount.UserAccount; import _VisualDVM.Constants; import _VisualDVM.Global; import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentJson; import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentsJson; import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentsSetJson; import _VisualDVM.GlobalData.CompilerOption.Json.OptionJson; import _VisualDVM.GlobalData.CompilerOption.Json.OptionsJson; import _VisualDVM.GlobalData.CompilerOption.Json.OptionsSetJson; import _VisualDVM.Passes.PassCode; import _VisualDVM.ServerObjectsCache.VisualCaches; import _VisualDVM.TestingSystem.Common.Group.Group; import _VisualDVM.TestingSystem.Common.Group.GroupsDBTable; import _VisualDVM.TestingSystem.Common.Test.Test; import _VisualDVM.TestingSystem.Common.Test.TestDBTable; import _VisualDVM.TestingSystem.Common.TestFile.TestFile; import _VisualDVM.TestingSystem.Common.TestFile.TestFilesDBTable; import _VisualDVM.TestingSystem.Common.TestingPackageToKill.TestingPackagesToKillDBTable; import _VisualDVM.TestingSystem.DVM.DVMCompilationOption.DVMCompilationOption; import _VisualDVM.TestingSystem.DVM.DVMCompilationOption.DVMCompilationOptionsDBTable; import _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet.DVMCompilationOptionsSet; import _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet.DVMCompilationOptionsSetsDBTable; import _VisualDVM.TestingSystem.DVM.DVMConfiguration.DVMConfiguration; import _VisualDVM.TestingSystem.DVM.DVMConfiguration.DVMConfigurationDBTable; import _VisualDVM.TestingSystem.DVM.DVMConfigurationGroup.DVMConfigurationGroup; import _VisualDVM.TestingSystem.DVM.DVMConfigurationGroup.DVMConfigurationGroupsDBTable; import _VisualDVM.TestingSystem.DVM.DVMConfigurationSettings.DVMConfigurationSettings; import _VisualDVM.TestingSystem.DVM.DVMConfigurationSettings.DVMConfigurationSettingsDBTable; import _VisualDVM.TestingSystem.DVM.DVMConfigurationTest.DVMConfigurationTest; import _VisualDVM.TestingSystem.DVM.DVMConfigurationTest.DVMConfigurationTestsDBTable; import _VisualDVM.TestingSystem.DVM.DVMEnvironment.DVMEnvironment; import _VisualDVM.TestingSystem.DVM.DVMEnvironment.DVMEnvironmentsDBTable; import _VisualDVM.TestingSystem.DVM.DVMEnvironmentsSet.DVMEnvironmentsSet; import _VisualDVM.TestingSystem.DVM.DVMEnvironmentsSet.DVMEnvironmentsSetsDBTable; import _VisualDVM.TestingSystem.DVM.DVMPackage.DVMPackage; import _VisualDVM.TestingSystem.DVM.DVMPackage.DVMPackageDBTable; import _VisualDVM.TestingSystem.DVM.DVMPackageConfiguration.DVMPackageConfiguration; import _VisualDVM.TestingSystem.DVM.DVMPackageConfiguration.DVMPackageConfigurationsDBTable; import _VisualDVM.TestingSystem.DVM.DVMSettings.DVMSettings; import _VisualDVM.TestingSystem.DVM.DVMSettings.DVMSettingsDBTable; import _VisualDVM.TestingSystem.DVM.DVMTasks.DVMRunTasksSet; import _VisualDVM.TestingSystem.SAPFOR.SapforConfiguration.SapforConfiguration; import _VisualDVM.TestingSystem.SAPFOR.SapforConfiguration.SapforConfigurationDBTable; import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationGroup.SapforConfigurationGroup; import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationGroup.SapforConfigurationGroupsDBTable; import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationSettings.SapforConfigurationSettings; import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationSettings.SapforConfigurationSettingsDBTable; import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationTest.SapforConfigurationTest; import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationTest.SapforConfigurationTestsDBTable; import _VisualDVM.TestingSystem.SAPFOR.SapforPackage.SapforPackage; import _VisualDVM.TestingSystem.SAPFOR.SapforPackage.SapforPackageDBTable; import _VisualDVM.TestingSystem.SAPFOR.SapforPackageConfiguration.SapforPackageConfiguration; import _VisualDVM.TestingSystem.SAPFOR.SapforPackageConfiguration.SapforPackageConfigurationsDBTable; import _VisualDVM.TestingSystem.SAPFOR.SapforSettings.SapforSettings; import _VisualDVM.TestingSystem.SAPFOR.SapforSettings.SapforSettingsDBTable; import _VisualDVM.TestingSystem.SAPFOR.SapforSettingsCommand.SapforSettingsCommand; import _VisualDVM.TestingSystem.SAPFOR.SapforSettingsCommand.SapforSettingsCommandsDBTable; import _VisualDVM.TestingSystem.SAPFOR.ServerSapfor.ServerSapfor; import _VisualDVM.TestingSystem.SAPFOR.ServerSapfor.ServerSapforState; import _VisualDVM.TestingSystem.SAPFOR.ServerSapfor.ServerSapforsDBTable; import javafx.util.Pair; import org.apache.commons.io.FileUtils; import java.io.File; import java.nio.file.Paths; import java.util.Comparator; import java.util.LinkedHashMap; import java.util.Vector; public class TestsDatabase extends SQLiteDatabase { public GroupsDBTable groups; //-- public TestDBTable tests; public TestFilesDBTable testsFiles; //--- public DVMSettingsDBTable dvmSettings; public DVMCompilationOptionsSetsDBTable dvmCompilationOptionsSets; public DVMCompilationOptionsDBTable dvmCompilationOptions; public DVMEnvironmentsSetsDBTable dvmEnvironmentsSets; public DVMEnvironmentsDBTable dvmEnvironments; public DVMConfigurationDBTable dvmConfigurations; public DVMConfigurationGroupsDBTable dvmConfigurationGroups; public DVMConfigurationTestsDBTable dvmConfigurationTests; public DVMConfigurationSettingsDBTable dvmConfigurationSettings; public DVMPackageDBTable dvmPackages; public DVMPackageConfigurationsDBTable dvmPackageConfigurations; public DVMRunTasksSet dvmRunTasks = new DVMRunTasksSet(); //-- public ServerSapforsDBTable serverSapfors; public SapforSettingsDBTable sapforSettings; public SapforSettingsCommandsDBTable sapforSettingsCommands; public SapforConfigurationDBTable sapforConfigurations; public SapforConfigurationGroupsDBTable sapforConfigurationGroups; public SapforConfigurationTestsDBTable sapforConfigurationTests; public SapforConfigurationSettingsDBTable sapforConfigurationSettings; public SapforPackageDBTable sapforPackages; public SapforPackageConfigurationsDBTable sapforPackageConfigurations; //-- public TestingPackagesToKillDBTable testingPackagesToKill; //-- public TestsDatabase() { super(Paths.get(System.getProperty("user.dir"), "Data", Constants.tests_db_name + ".sqlite").toFile()); } @Override protected void initAllTables() throws Exception { addTable(groups = new GroupsDBTable()); addTable(tests = new TestDBTable()); addTable(testsFiles = new TestFilesDBTable()); //-- addTable(dvmSettings = new DVMSettingsDBTable()); //-- addTable(dvmCompilationOptionsSets = new DVMCompilationOptionsSetsDBTable()); addTable(dvmCompilationOptions = new DVMCompilationOptionsDBTable()); addTable(dvmEnvironmentsSets = new DVMEnvironmentsSetsDBTable()); addTable(dvmEnvironments = new DVMEnvironmentsDBTable()); //--- addTable(dvmConfigurations = new DVMConfigurationDBTable()); addTable(dvmConfigurationGroups = new DVMConfigurationGroupsDBTable()); addTable(dvmConfigurationTests = new DVMConfigurationTestsDBTable()); addTable(dvmConfigurationSettings = new DVMConfigurationSettingsDBTable()); addTable(dvmPackages = new DVMPackageDBTable()); addTable(dvmPackageConfigurations = new DVMPackageConfigurationsDBTable()); //- addTable(serverSapfors = new ServerSapforsDBTable()); addTable(sapforSettings = new SapforSettingsDBTable()); addTable(sapforSettingsCommands = new SapforSettingsCommandsDBTable()); addTable(sapforConfigurations = new SapforConfigurationDBTable()); addTable(sapforConfigurationGroups = new SapforConfigurationGroupsDBTable()); addTable(sapforConfigurationTests = new SapforConfigurationTestsDBTable()); addTable(sapforConfigurationSettings = new SapforConfigurationSettingsDBTable()); addTable(sapforPackages = new SapforPackageDBTable()); addTable(sapforPackageConfigurations = new SapforPackageConfigurationsDBTable()); //-- addTable(testingPackagesToKill = new TestingPackagesToKillDBTable()); } @Override public PassCode getSynchronizePassCode() { return PassCode.SynchronizeTests; } public Vector getFirstActiveSapforPackagesCopies() { Vector res = new Vector<>(); Vector packages = new Vector<>(); SapforPackage activePackage = null; //1. получить активные пакеты. for (SapforPackage p : sapforPackages.Data.values()) { switch (p.state) { case Done: case Aborted: case Draft: case ConnectionError: case DoneWithErrors: break; default: packages.add(p); break; } } //2. отсортировать по приоритету. packages.sort(new Comparator() { @Override public int compare(SapforPackage o1, SapforPackage o2) { return Integer.compare(o1.state.ordinal(), o2.state.ordinal()); } }); if (!packages.isEmpty()) { activePackage = packages.lastElement(); if (activePackage.state.equals(TasksPackageState.Queued)) { activePackage.state = TasksPackageState.TestsSynchronize; try { Update(activePackage); } catch (Exception ex) { ex.printStackTrace(); } } res.add(new SapforPackage(activePackage)); ; //копия чтобы не было конфликта доступа с нитью планировщика. } return res; } public Vector getFirstActiveDVMPackagesCopies() { Vector res = new Vector<>(); //-- LinkedHashMap> packagesByMachines = new LinkedHashMap<>(); //---- //1. Получить список активных пакетов по машинам. for (DVMPackage dvmPackage : dvmPackages.Data.values()) { switch (dvmPackage.state) { case Done: case DoneWithErrors: case Aborted: case Draft: case ConnectionError: break; default: //активен. Vector packages = null; //-- if (packagesByMachines.containsKey(dvmPackage.machine_address)) { packages = packagesByMachines.get(dvmPackage.machine_address); } else { packages = new Vector<>(); packagesByMachines.put(dvmPackage.machine_address, packages); } packages.add(dvmPackage); break; } } //2. Выбрать для каждой машины наиболее приоритетный пакет. for (String machine : packagesByMachines.keySet()) { Vector packages = packagesByMachines.get(machine); if (!packages.isEmpty()) { packages.sort(new Comparator() { @Override public int compare(DVMPackage o1, DVMPackage o2) { return Integer.compare(o1.state.ordinal(), o2.state.ordinal()); } }); //- DVMPackage activePackage = packages.lastElement(); if (activePackage.state.equals(TasksPackageState.Queued)) { activePackage.state = TasksPackageState.TestsSynchronize; try { Update(activePackage); } catch (Exception ex) { ex.printStackTrace(); } } res.add(new DVMPackage(activePackage)); //копия чтобы не было конфликта доступа с нитью планировщика. } } return res; } //-- public void DetectTestMinMaxDim(ServerSapfor serverSapfor, Group group, Test test) throws Exception { switch (group.language) { case fortran: if (serverSapfor != null) { Sapfor.getTestMinMaxDim_F(new File(serverSapfor.call_command), test); Update(test); } break; case c: Sapfor.getTestMinMaxDime_C(test); Update(test); break; } } public void importTestFile(Test test, File file) throws Exception { File testDirectory = new File(Global.TestsDirectory, String.valueOf(test.id)); Utils_.CheckAndCleanDirectory(testDirectory); File dst = Paths.get(testDirectory.getAbsolutePath(), file.getName()).toFile(); FileUtils.copyFile(file, dst); } public void CreateTestFromSingleFile(UserAccount account, ServerSapfor sapfor, Group group, File file, String testDescription) throws Exception { Test test = new Test(); test.description = testDescription; test.sender_name = account.name; test.sender_address = account.email; test.group_id = group.id; Insert(test); //->> importTestFile(test, file); TestFile testFile = new TestFile(test, file); Insert(testFile); //-- DetectTestMinMaxDim(sapfor, group, test); } public void RefreshGroup(UserAccount account, ServerSapfor sapfor, Pair> groupData) throws Exception { Group group = groupData.getKey(); Vector files = groupData.getValue(); //-- Group oldGroup = groups.getGroupByDescription(group.language, group.description); if (oldGroup == null) { Insert(group); for (File file : files) { String testDescription = Utils_.getNameWithoutExtension(file.getName()) + "_" + group.language.getDVMCompile(); CreateTestFromSingleFile(account, sapfor, group, file, testDescription); } } else { for (File file : files) { String testDescription = Utils_.getNameWithoutExtension(file.getName()) + "_" + group.language.getDVMCompile(); Test oldTest = tests.getStandardTestByDescription(oldGroup.id, testDescription); if (oldTest == null) { CreateTestFromSingleFile(account, sapfor, oldGroup, file, testDescription); } else { importTestFile(oldTest, file); } } } } public Vector getFirstActiveDVMPackageCopyForMachineURL(String arg) { Vector res = new Vector<>(); Vector machinePackages = new Vector<>(); //-- //1. Получить список активных пакетов для машины. for (DVMPackage dvmPackage : dvmPackages.Data.values()) { switch (dvmPackage.state) { case Done: case DoneWithErrors: case Aborted: case Draft: case ConnectionError: break; default: if (dvmPackage.getMachineURL().equals(arg)) machinePackages.add(dvmPackage); break; } } if (!machinePackages.isEmpty()) { machinePackages.sort(new Comparator() { @Override public int compare(DVMPackage o1, DVMPackage o2) { return Integer.compare(o1.state.ordinal(), o2.state.ordinal()); } }); //- DVMPackage activePackage = machinePackages.lastElement(); if (activePackage.state.equals(TasksPackageState.Queued)) { activePackage.state = TasksPackageState.TestsSynchronize; try { Update(activePackage); } catch (Exception ex) { ex.printStackTrace(); } } res.add(new DVMPackage(activePackage)); } return res; } public ServerSapfor getSapforCopyForCompilation() { for (ServerSapfor serverSapfor : serverSapfors.Data.values()) { if (serverSapfor.state.equals(ServerSapforState.Queued)) { return new ServerSapfor(serverSapfor); } } return null; } public ServerSapfor getSapforForVersion(String version_in) { for (ServerSapfor serverSapfor : serverSapfors.Data.values()) { if (serverSapfor.version.equals(version_in)) return serverSapfor; } return null; } public Integer getInstalledSapforMaxVersion() { int max_version = CommonConstants.Nan; for (ServerSapfor sapfor : serverSapfors.Data.values()) { if (sapfor.state.equals(ServerSapforState.Done)) { int version = CommonConstants.Nan; try { version = Integer.parseInt(sapfor.version); } catch (Exception ex) { ex.printStackTrace(); } if (version > max_version) max_version = version; } } return max_version; } public boolean hasActiveSapfors() { for (ServerSapfor serverSapfor : serverSapfors.Data.values()) { if (serverSapfor.state.isActive()) return true; } return false; } public void UnselectAllGTC() { groups.getUI().SelectAll(false); tests.getUI().SelectAll(false); dvmConfigurations.getUI().SelectAll(false); } //todo возможно рассмотреть вариант с синхроннизацией тестов для пакетов через команду серверу а не в нити //во избежание конфликта доступа,или удалением тестов во время копирования(?) @Override public void DropUI() { super.DropUI(); dvmConfigurations.ClearUI(); groups.ClearUI(); sapforConfigurations.ClearUI(); serverSapfors.ClearUI(); dvmPackages.ClearUI(); sapforPackages.ClearUI(); sapforSettings.ClearUI(); dvmSettings.ClearUI(); } @Override public void ResetUI() { VisualCaches.ClearDataForClass(DVMConfiguration.class); VisualCaches.ClearDataForClass(SapforConfiguration.class); VisualCaches.ClearDataForClass(DVMPackage.class); VisualCaches.ClearDataForClass(SapforPackage.class); //server.db.machines dvmConfigurations.ShowUI(); groups.ShowUI(); sapforConfigurations.ShowUI(); serverSapfors.ShowUI(); dvmPackages.ShowUI(); sapforPackages.ShowUI(); sapforSettings.ShowUI(); dvmSettings.ShowUI(); super.ResetUI(); } public void saveTestFiles(Test test) throws Exception { for (TestFile file : test.files) { file.test_id = test.id; Insert(file); } test.files = null; } public void DeleteTestFiles(Test test) throws Exception { Vector files = getVectorByFK(test, TestFile.class); for (TestFile file : files) Delete(file); } public void saveDVMPackageConfigurations(DVMPackage dvmPackage) throws Exception { for (DVMPackageConfiguration packageConfiguration : dvmPackage.configurations) { packageConfiguration.dvmpackage_id = dvmPackage.id; Insert(packageConfiguration); } dvmPackage.configurations = null; } public void saveSapforPackageConfigurations(SapforPackage dvmPackage) throws Exception { for (SapforPackageConfiguration packageConfiguration : dvmPackage.configurations) { packageConfiguration.sapforpackage_id = dvmPackage.id; Insert(packageConfiguration); } dvmPackage.configurations = null; } public Vector getDVMConfigurationGroupsIds(DVMConfiguration configuration) { Vector res = new Vector<>(); for (DVMConfigurationGroup dvmConfigurationGroup : dvmConfigurationGroups.Data.values()) { if (dvmConfigurationGroup.dvmconfiguration_id == configuration.id) res.add(dvmConfigurationGroup.group_id); } return res; } public Vector getDVMConfigurationTestsIds(DVMConfiguration configuration) { Vector res = new Vector<>(); if (configuration.groupsOnly == 0) { for (DVMConfigurationTest dvmConfigurationTest : dvmConfigurationTests.Data.values()) { if (dvmConfigurationTest.dvmconfiguration_id == configuration.id) res.add(dvmConfigurationTest.test_id); } } else { Vector groups_ids = getDVMConfigurationGroupsIds(configuration); for (int groud_id : groups_ids) res.addAll(getFKi(groud_id, Group.class, Test.class)); } return res; } public Vector getDVMConfigurationSettingsIds(DVMConfiguration configuration) { Vector res = new Vector<>(); for (DVMConfigurationSettings dvmConfigurationSettings : dvmConfigurationSettings.Data.values()) { if (dvmConfigurationSettings.dvmconfiguration_id == configuration.id) res.add(dvmConfigurationSettings.dvmsettings_id); } return res; } //-- public Vector getSapforConfigurationGroupsIds(SapforConfiguration configuration) { Vector res = new Vector<>(); for (SapforConfigurationGroup sapforConfigurationGroup : sapforConfigurationGroups.Data.values()) { if (sapforConfigurationGroup.sapforconfiguration_id == configuration.id) res.add(sapforConfigurationGroup.group_id); } return res; } public Vector getSapforConfigurationTestsIds(SapforConfiguration configuration) { Vector res = new Vector<>(); if (configuration.groupsOnly == 0) { for (SapforConfigurationTest sapforConfigurationTest : sapforConfigurationTests.Data.values()) { if (sapforConfigurationTest.sapforconfiguration_id == configuration.id) res.add(sapforConfigurationTest.test_id); } } else { Vector groups_ids = getSapforConfigurationGroupsIds(configuration); for (int groud_id : groups_ids) res.addAll(getFKi(groud_id, Group.class, Test.class)); } return res; } public Vector getSapforConfigurationSettingsIds(SapforConfiguration configuration) { Vector res = new Vector<>(); for (SapforConfigurationSettings sapforConfigurationSettings : sapforConfigurationSettings.Data.values()) { if (sapforConfigurationSettings.sapforconfiguration_id == configuration.id) res.add(sapforConfigurationSettings.sapforsettings_id); } return res; } //-- public LinkedHashMap> getDVMConfigurationGroupsTestsIds(DVMConfiguration configuration) { LinkedHashMap> res = new LinkedHashMap<>(); Vector all_tests_ids = getDVMConfigurationTestsIds(configuration); for (int group_id : getDVMConfigurationGroupsIds(configuration)) { Vector test_ids = new Vector<>(); for (int test_id : all_tests_ids) { if (tests.get(test_id).group_id == group_id) test_ids.add(test_id); } res.put(group_id, test_ids); } return res; } public LinkedHashMap> getSapforConfigurationGroupsTestsIds(SapforConfiguration configuration) { LinkedHashMap> res = new LinkedHashMap<>(); Vector all_tests_ids = getSapforConfigurationTestsIds(configuration); for (int group_id : getSapforConfigurationGroupsIds(configuration)) { Vector test_ids = new Vector<>(); for (int test_id : all_tests_ids) { if (tests.get(test_id).group_id == group_id) test_ids.add(test_id); } res.put(group_id, test_ids); } return res; } //-- public Vector getDVMPackageConfigurationsIds(DVMPackage dvmPackage) { Vector res = new Vector<>(); for (DVMPackageConfiguration dvmPackageConfiguration : dvmPackageConfigurations.Data.values()) { if (dvmPackageConfiguration.dvmpackage_id == dvmPackage.id) res.add(dvmPackageConfiguration.dvmconfiguration_id); } return res; } public Vector getSapforPackageConfigurationsIds(SapforPackage sapforPackage) { Vector res = new Vector<>(); for (SapforPackageConfiguration sapforPackageConfiguration : sapforPackageConfigurations.Data.values()) { if (sapforPackageConfiguration.sapforpackage_id == sapforPackage.id) res.add(sapforPackageConfiguration.sapforconfiguration_id); } return res; } //-- public OptionsSetJson convertOptionsToJson(DVMSettings dvmSettings_in) { OptionsSetJson res = new OptionsSetJson(); if (dvmSettings_in.id != CommonConstants.Nan) { Vector optionsSets = getVectorByFK(dvmSettings_in, DVMCompilationOptionsSet.class); for (DVMCompilationOptionsSet optionsSet : optionsSets) { Vector options = getVectorByFK(optionsSet, DVMCompilationOption.class); OptionsJson optionsJson = new OptionsJson(); for (DVMCompilationOption option : options) { optionsJson.values.add(new OptionJson(option.name, option.value)); } res.values.add(optionsJson); } } return res; } public EnvironmentsSetJson convertEnvironmentsToJson(DVMSettings dvmSettings_in) { EnvironmentsSetJson res = new EnvironmentsSetJson(); if (dvmSettings_in.id != CommonConstants.Nan) { Vector environmentsSets = getVectorByFK(dvmSettings_in, DVMEnvironmentsSet.class); for (DVMEnvironmentsSet environmentsSet : environmentsSets) { Vector environments = getVectorByFK(environmentsSet, DVMEnvironment.class); EnvironmentsJson environmentsJson = new EnvironmentsJson(); for (DVMEnvironment option : environments) { environmentsJson.values.add(new EnvironmentJson(option.name, option.value)); } res.values.add(environmentsJson); } } return res; } public void DeleteDVMSettingsOptions(DVMSettings dvmSettings) throws Exception { Vector optionsSets = getVectorByFK(dvmSettings, DVMCompilationOptionsSet.class); for (DVMCompilationOptionsSet optionsSet : optionsSets) { DeleteDependencies(optionsSet); Delete(optionsSet); } } public void InsertDVMSettingsOptions(DVMSettings dvmSettings) throws Exception { OptionsSetJson optionsSetJson = Utils_.gson.fromJson(dvmSettings.packedCompilationOptionsJson, OptionsSetJson.class); for (OptionsJson optionsJson : optionsSetJson.values) { DVMCompilationOptionsSet optionsSet = new DVMCompilationOptionsSet(dvmSettings); Insert(optionsSet); for (OptionJson optionJson : optionsJson.values) { DVMCompilationOption option = new DVMCompilationOption(); option.dvmcompilationoptionsset_id = optionsSet.id; option.name = optionJson.name; option.value = optionJson.value; Insert(option); } } } public void DeleteDVMSettingsEnvironments(DVMSettings dvmSettings) throws Exception { Vector environmentsSets = getVectorByFK(dvmSettings, DVMEnvironmentsSet.class); for (DVMEnvironmentsSet environmentsSet : environmentsSets) { DeleteDependencies(environmentsSet); Delete(environmentsSet); } } public void InsertDVMSettingsEnvironments(DVMSettings dvmSettings) throws Exception { EnvironmentsSetJson environmentsSetJson = Utils_.gson.fromJson(dvmSettings.packedRunEnvironmentValuesJson, EnvironmentsSetJson.class); for (EnvironmentsJson environmentsJson : environmentsSetJson.values) { DVMEnvironmentsSet environmentsSet = new DVMEnvironmentsSet(dvmSettings); Insert(environmentsSet); for (EnvironmentJson environmentJson : environmentsJson.values) { DVMEnvironment environment = new DVMEnvironment(); environment.dvmenvironmentsset_id = environmentsSet.id; environment.name = environmentJson.name; environment.value = environmentJson.value; Insert(environment); } } } //-- public void CloneDVMSettings(DVMSettings dvmSettings_src, DVMSettings dvmSettings_dst) throws Exception { //-- Vector optionsSets_src = getVectorByFK(dvmSettings_src, DVMCompilationOptionsSet.class); for (DVMCompilationOptionsSet optionsSet_src : optionsSets_src) { DVMCompilationOptionsSet optionsSet_dst = new DVMCompilationOptionsSet(dvmSettings_dst); Insert(optionsSet_dst); //-- Vector options_src = getVectorByFK(optionsSet_src, DVMCompilationOption.class); Vector options_dst = new Vector<>(); //-- for (DVMCompilationOption option_src : options_src) { DVMCompilationOption option_dst = new DVMCompilationOption(); option_dst.dvmcompilationoptionsset_id = optionsSet_dst.id; option_dst.name = option_src.name; option_dst.value = option_src.value; Insert(option_dst); } } //-- Vector environmentsSets_src = getVectorByFK(dvmSettings_src, DVMEnvironmentsSet.class); for (DVMEnvironmentsSet environmentsSet_src : environmentsSets_src) { DVMEnvironmentsSet environmentsSet_dst = new DVMEnvironmentsSet(dvmSettings_dst); Insert(environmentsSet_dst); //-- Vector environments_src = getVectorByFK(environmentsSet_src, DVMEnvironment.class); Vector environments_dst = new Vector<>(); //-- for (DVMEnvironment environment_src : environments_src) { DVMEnvironment environment_dst = new DVMEnvironment(); environment_dst.dvmenvironmentsset_id = environmentsSet_dst.id; environment_dst.name = environment_src.name; environment_dst.value = environment_src.value; Insert(environment_dst); } } } public void CloneSapforSettings(SapforSettings src, SapforSettings dst) throws Exception { for (SapforSettingsCommand src_command : getVectorByFK(src, SapforSettingsCommand.class)) { SapforSettingsCommand dst_command = new SapforSettingsCommand(); dst_command.sapforsettings_id = dst.id; dst_command.passCode = src_command.passCode; Insert(dst_command); } } //-- public void Patch() throws Exception { /* Vector sets = new Vector<>(); for (DVMSettings dvm_settings : dvmSettings.Data.values()) { OptionsSetJson optionsSetJson = Utils_.gson.fromJson(dvm_settings.packedCompilationOptionsJson, OptionsSetJson.class); for (OptionsJson optionsJson : optionsSetJson.values) { DVMCompilationOptionsSet set = new DVMCompilationOptionsSet(dvm_settings); set.options = new Vector<>(); for (OptionJson optionJson : optionsJson.values) { set.options.add(new DVMCompilationOption(optionJson.name, optionJson.value)); } sets.add(set); } } BeginTransaction(); for (DVMCompilationOptionsSet set : sets) { Insert(set); for (DVMCompilationOption option : set.options) { option.dvmcompilationoptionsset_id = set.id; Insert(option); } } Commit(); */ /* Vector sets = new Vector<>(); for (DVMSettings dvm_settings : dvmSettings.Data.values()) { EnvironmentsSetJson environmentsSetJson = Utils_.gson.fromJson(dvm_settings.packedRunEnvironmentValuesJson, EnvironmentsSetJson.class); for (EnvironmentsJson environmentsJson : environmentsSetJson.values) { DVMEnvironmentsSet set = new DVMEnvironmentsSet(dvm_settings); set.environments = new Vector<>(); for (EnvironmentJson environmentJson : environmentsJson.values) { set.environments.add(new DVMEnvironment(environmentJson.name, environmentJson.value)); } sets.add(set); } } BeginTransaction(); for (DVMEnvironmentsSet set : sets) { Insert(set); for (DVMEnvironment option : set.environments) { option.dvmenvironmentsset_id = set.id; Insert(option); } } Commit(); */ } public static String printOptionsLine(Vector options) { Vector res = new Vector<>(); for (DVMCompilationOption option : options) res.add(option.print()); return String.join(" ", res); } public static String printEnvironmentsLine(Vector environments) { Vector res = new Vector<>(); for (DVMEnvironment environment : environments) res.add(environment.print()); return String.join(" ", res); } public Vector> getTasksParameters(DVMSettings dvmSettings_in) { //уравниваем количество наборов опций и окружений и сопоставляем 1 к 1 Vector> res = new Vector<>(); Vector optionsSets = getVectorByFK(dvmSettings_in, DVMCompilationOptionsSet.class); Vector environmentsSets = getVectorByFK(dvmSettings_in, DVMEnvironmentsSet.class); //-- for (int i = 0; i < optionsSets.size(); ++i) { Vector options = getVectorByFK(optionsSets.get(i), DVMCompilationOption.class); Vector environments = getVectorByFK(environmentsSets.get(i), DVMEnvironment.class); String optionsLine = printOptionsLine(options); String environmentsLine = (i < environmentsSets.size()) ? printEnvironmentsLine(environments) : ""; res.add(new Pair<>( optionsLine, environmentsLine)); } if (optionsSets.size() < environmentsSets.size()) { for (int i = optionsSets.size(); i < environmentsSets.size(); ++i) { res.add(new Pair<>( "", printEnvironmentsLine(getVectorByFK(environmentsSets.get(i), DVMEnvironment.class)) )); } } return res; } }