425 lines
24 KiB
Java
425 lines
24 KiB
Java
package Repository.Server;
|
||
import Common.Database.Objects.DBObject;
|
||
import Common.Utils.CommonUtils;
|
||
import _VisualDVM.Global;
|
||
import Common_old.Utils.Utils;
|
||
import GlobalData.Account.Account;
|
||
import GlobalData.Machine.Machine;
|
||
import GlobalData.Machine.MachineType;
|
||
import GlobalData.RemoteFile.RemoteFile;
|
||
import GlobalData.User.User;
|
||
import ProjectData.LanguageName;
|
||
import Repository.BugReport.BugReport;
|
||
import Repository.BugReport.BugReportInterface;
|
||
import Repository.BugReportsDatabase;
|
||
import Repository.Component.ComponentType;
|
||
import Repository.EmailMessage;
|
||
import Repository.RepositoryRefuseException;
|
||
import Repository.RepositoryServer;
|
||
import Repository.Subscribes.Subscriber;
|
||
import Visual_DVM_2021.Passes.All.ArchivesBackupPass;
|
||
import Visual_DVM_2021.Passes.All.UnzipFolderPass;
|
||
import Visual_DVM_2021.Passes.All.ZipFolderPass;
|
||
import javafx.util.Pair;
|
||
import org.apache.commons.io.FileUtils;
|
||
|
||
import java.io.BufferedWriter;
|
||
import java.io.File;
|
||
import java.io.FileWriter;
|
||
import java.nio.file.Files;
|
||
import java.nio.file.Paths;
|
||
import java.util.*;
|
||
public class ComponentsServer extends RepositoryServer<BugReportsDatabase> {
|
||
public static final String server_dvm_drv = "/home/DVM/dvm_current/dvm_sys/bin/dvm_drv";
|
||
public ComponentsServer() {
|
||
super(BugReportsDatabase.class);
|
||
}
|
||
@Override
|
||
public int getPort() {
|
||
return Global.properties.ComponentsServerPort;
|
||
}
|
||
@Override
|
||
protected void checkTargets(EmailMessage message_in) {
|
||
Vector<String> checkedTargets = new Vector<>();
|
||
for (String email: message_in.targets){
|
||
if (db.subscribers.containsKey(email)){
|
||
Subscriber subscriber = db.subscribers.get(email);
|
||
if (subscriber.mailOn>0){
|
||
checkedTargets.add(email);
|
||
}
|
||
}else checkedTargets.add(email); //если почта не зарегана значит это мейл с регистрацией.
|
||
}
|
||
message_in.targets = checkedTargets;
|
||
}
|
||
@Override
|
||
public void afterDeleteAction(DBObject object) throws Exception {
|
||
if (object instanceof BugReport) {
|
||
BugReport bugReport = (BugReport) object;
|
||
if (!bugReport.project_version.isEmpty())
|
||
Utils.delete_with_check(BugReportInterface.getArchiveFile(bugReport));
|
||
}
|
||
}
|
||
@Override
|
||
public void StartAction() throws Exception {
|
||
if (Global.properties.EmailAdminsOnStart) {
|
||
EmailMessage message = new EmailMessage(
|
||
"Сервер Sapfor запущен",
|
||
new Date().toString(),
|
||
new Vector<>()
|
||
);
|
||
Email(message);
|
||
}
|
||
}
|
||
@Override
|
||
protected void Session() throws Exception {
|
||
BugReport bugReport = null;
|
||
Subscriber subscriber = null;
|
||
Account account = null;
|
||
if (!Global.properties.OldServer) {
|
||
switch (code) {
|
||
//<editor-fold desc="Регистрация">
|
||
case CheckSubscriberRole:
|
||
Print("Проверить роль пользователя");
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
account = (Account) request.object;
|
||
if (db.subscribers.containsKey(account.email)) {
|
||
subscriber = db.subscribers.get(account.email);
|
||
} else {
|
||
subscriber = new Subscriber();
|
||
subscriber.name = account.name;
|
||
subscriber.address = account.email;
|
||
subscriber.mailOn = 1;
|
||
db.Insert(subscriber);
|
||
}
|
||
response.object = subscriber; //возвращаем информацию о подписчике.
|
||
break;
|
||
//</editor-fold>
|
||
//<editor-fold desc="БАГ РЕПОРТЫ">
|
||
case ReceiveAllArchives:
|
||
Print("Отправить клиенту архив всех архивов баг репортов");
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
ZipFolderPass zip = new ZipFolderPass();
|
||
File archives = new File(CommonUtils.getDateName("Bugs"));
|
||
if (zip.Do("Bugs", archives.getAbsolutePath())) {
|
||
response.object = CommonUtils.fileToBytes(archives);
|
||
Print("Архив успешно запакован");
|
||
} else throw new RepositoryRefuseException("Не удалось запаковать архивы");
|
||
break;
|
||
case UpdateBugReport:
|
||
//-
|
||
BugReport oldBugReport = (BugReport) request.object;
|
||
Print("Обновить баг репорт " + oldBugReport.id);
|
||
if (db.bugReports.containsKey(oldBugReport.id)) {
|
||
bugReport = db.bugReports.get(oldBugReport.id);
|
||
bugReport.SynchronizeFields(oldBugReport);
|
||
bugReport.change_date = oldBugReport.change_date;
|
||
db.Update(bugReport);
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
} else
|
||
throw new RepositoryRefuseException("Баг репорт с ключом " + oldBugReport.id + " не существует.");
|
||
break;
|
||
case UpdateBugReportField: //нужно для дополнений полей
|
||
//-
|
||
BugReport oldBugReport_ = (BugReport) request.object;
|
||
Print("Обновить поле " + request.arg + " баг репорта " + oldBugReport_.id);
|
||
if (db.bugReports.containsKey(oldBugReport_.id)) {
|
||
bugReport = db.bugReports.get(oldBugReport_.id);
|
||
Object newValue = BugReport.class.getField(request.arg).get(oldBugReport_);
|
||
BugReport.class.getField(request.arg).set(bugReport, newValue);
|
||
bugReport.change_date = oldBugReport_.change_date;
|
||
db.Update(bugReport);
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
} else
|
||
throw new RepositoryRefuseException("Баг репорт с ключом " + oldBugReport_.id + " не существует.");
|
||
break;
|
||
case ReceiveBugReportsDatabase:
|
||
Print("Получить базу данных баг репортов");
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = CommonUtils.fileToBytes(db.getFile());
|
||
break;
|
||
case ReceiveBugReport:
|
||
Print("Скачать баг репорт по ключу " + request.arg);
|
||
File bugArchive = Paths.get(CommonUtils.Home, "Bugs", request.arg).toFile();
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = CommonUtils.fileToBytes(bugArchive);
|
||
break;
|
||
case SendBugReport:
|
||
Print("Отправить баг репорт " + request.arg);
|
||
File bugArchive1 = Paths.get(CommonUtils.Home, "Bugs", request.arg).toFile();
|
||
CommonUtils.bytesToFile((byte[]) request.object, bugArchive1);
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
break;
|
||
//</editor-fold>
|
||
case GetComponentsBackups:
|
||
Print("Получить список сохраненных версий компонента " + request.arg);
|
||
File backupsDirectory = Paths.get(CommonUtils.Home, "Components", request.arg, "Backups").toFile();
|
||
//--
|
||
if (backupsDirectory.exists()) {
|
||
File[] files = backupsDirectory.listFiles(File::isFile);
|
||
if (files != null) {
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
Vector<RemoteFile> res = new Vector<>();
|
||
for (File file : files)
|
||
res.add(new RemoteFile(file.getAbsolutePath(), false)); //тут всегда линух.
|
||
response.object = res;
|
||
} else
|
||
throw new RepositoryRefuseException("Не удалось получить список предыдущих версий");
|
||
} else {
|
||
//баги еще не создавались. штатная ситуация.
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = new Vector<>();
|
||
}
|
||
break;
|
||
case PublishComponent:
|
||
String[] packed = request.arg.split("\n");
|
||
String sComponentType = packed[0];
|
||
String componentFileName = packed[1];
|
||
String sComponentVersion = packed[2];
|
||
String componentChangeRecord = request.arg.substring(
|
||
sComponentType.length() +
|
||
componentFileName.length() +
|
||
sComponentVersion.length() +
|
||
3
|
||
);
|
||
Print("Опубликовать компонент " + sComponentType);
|
||
File componentFile = Paths.get(CommonUtils.Home, "Components", sComponentType, componentFileName).toFile();
|
||
File versionFile = Paths.get(CommonUtils.Home, "Components", sComponentType, "version.txt").toFile();
|
||
File backupsFolder = Paths.get(CommonUtils.Home, "Components", sComponentType, "Backups").toFile();
|
||
//0 архивация старой версии, если она есть.
|
||
if (componentFile.exists()) {
|
||
String versionText = "";
|
||
if (versionFile.exists())
|
||
versionText = Utils.ReadAllText(versionFile);
|
||
//---->>
|
||
Utils.CheckDirectory(backupsFolder);
|
||
Utils.keepNewFiles(backupsFolder, Global.properties.ComponentsBackUpsCount);
|
||
//-->>
|
||
File backupFile = new File(backupsFolder, sComponentType + "_" + versionText);
|
||
if (backupFile.exists())
|
||
Utils.delete_with_check(backupFile);
|
||
FileUtils.moveFile(componentFile, backupFile);
|
||
}
|
||
//1 распаковка компонента
|
||
CommonUtils.bytesToFile((byte[]) request.object, componentFile);
|
||
//2 запись версии компонента
|
||
FileUtils.writeStringToFile(versionFile, sComponentVersion);
|
||
//3 запись в журнал компонента
|
||
File changesLog = Paths.get(CommonUtils.Home, "Components", sComponentType, "changes.txt").toFile();
|
||
FileWriter writer = new FileWriter(changesLog.getAbsolutePath(), true);
|
||
BufferedWriter bufferWriter = new BufferedWriter(writer);
|
||
bufferWriter.write(componentChangeRecord);
|
||
bufferWriter.close();
|
||
//-
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
break;
|
||
case UpdateComponentMinimalVersion:
|
||
String[] packed_ = request.arg.split("\n");
|
||
String sComponentType_ = packed_[0];
|
||
String sComponentMinimalVersion = packed_[1];
|
||
Print("Поднять минимальную версию компонента " + sComponentType_);
|
||
File minimal_versionFile = Paths.get(CommonUtils.Home, "Components", sComponentType_, "minimal_version.txt").toFile();
|
||
FileUtils.writeStringToFile(minimal_versionFile, sComponentMinimalVersion);
|
||
//-
|
||
//3 запись в журнал компонента
|
||
File changesLog_ = Paths.get(CommonUtils.Home, "Components", sComponentType_, "changes.txt").toFile();
|
||
FileWriter writer_ = new FileWriter(changesLog_.getAbsolutePath(), true);
|
||
BufferedWriter bufferWriter_ = new BufferedWriter(writer_);
|
||
bufferWriter_.write("Минимальная версия поднята до " + sComponentMinimalVersion + "\n");
|
||
bufferWriter_.close();
|
||
//-
|
||
//-
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
break;
|
||
case ReceiveComponent:
|
||
String[] packed1 = request.arg.split("\n");
|
||
//тип/имя файла
|
||
File componentFile1 = Paths.get(CommonUtils.Home, "Components", packed1[0], packed1[1]).toFile();
|
||
Print("Получить компонент " + packed1[0]);
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = CommonUtils.fileToBytes(componentFile1);
|
||
break;
|
||
default:
|
||
throw new RepositoryRefuseException("Неподдерживаемый код: " + code);
|
||
case GetComponentsVersions:
|
||
Print("Получить актуальные версии компонентов (NEW)");
|
||
String[] types = request.arg.split("\n");
|
||
LinkedHashMap<ComponentType, String> response_actual_versions_ = new LinkedHashMap<>();
|
||
for (String sType : types) {
|
||
ComponentType componentType = ComponentType.valueOf(sType);
|
||
File vFile = Paths.get(CommonUtils.Home, "Components", sType, "version.txt").toFile();
|
||
String v_string = CommonUtils.removeCharacters(
|
||
Utils.ReadAllText(vFile),
|
||
"\n", "\r"
|
||
);
|
||
response_actual_versions_.put(componentType, v_string);
|
||
}
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = response_actual_versions_;
|
||
break;
|
||
case GetComponentsMinimalVersions:
|
||
Print("Получить минимальные версии компонентов (NEW)");
|
||
String[] types_ = request.arg.split("\n");
|
||
LinkedHashMap<ComponentType, String> response_minimal_versions_ = new LinkedHashMap<>();
|
||
for (String sType : types_) {
|
||
ComponentType componentType = ComponentType.valueOf(sType);
|
||
File vFile = Paths.get(CommonUtils.Home, "Components", sType, "minimal_version.txt").toFile();
|
||
String mv_string = CommonUtils.removeCharacters(
|
||
Utils.ReadAllText(vFile),
|
||
"\n", "\r"
|
||
);
|
||
response_minimal_versions_.put(componentType, mv_string);
|
||
}
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = response_minimal_versions_;
|
||
break;
|
||
case GetComponentChangesLog:
|
||
Print("Получить журнал изменений компонента " + request.arg);
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = CommonUtils.fileToBytes(Paths.get(CommonUtils.Home, "Components", request.arg, "changes.txt").toFile());
|
||
break;
|
||
case CheckURLRegistered:
|
||
Print("Проверить учетную запись на машине");
|
||
String[] data = request.arg.split("\n");
|
||
String email = data[0];
|
||
String machineURL = data[1];
|
||
String login = data[2];
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
response.object = db.workspaces.findWorkspace(email, machineURL, login);
|
||
break;
|
||
case DVMConvertProject:
|
||
Print("Сконвертировать проект в DVM код");
|
||
response = new ServerExchangeUnit_2021(ServerCode.OK);
|
||
String[] args = request.arg.split("\n");
|
||
//-
|
||
String projectName = args[0];
|
||
LanguageName projectLanguage = LanguageName.valueOf(args[1]);
|
||
String options = args[2];
|
||
Vector<String> filesNames = new Vector<>(Arrays.asList(args).subList(3, args.length));
|
||
//-
|
||
File workspace = Utils.getTempFileName("convertation");
|
||
FileUtils.forceMkdir(workspace);
|
||
File archive = new File(workspace, projectName + ".zip");
|
||
request.Unpack(archive);
|
||
File project = new File(workspace, projectName);
|
||
Vector<String> badFiles = new Vector<>();
|
||
if (unzip.Do(archive.getAbsolutePath(), workspace.getAbsolutePath()) && project.exists()) {
|
||
String output = "";
|
||
for (String fileName : filesNames) {
|
||
File program = Paths.get(project.getAbsolutePath(), fileName).toFile();
|
||
//--
|
||
File convertedProgram = Paths.get(program.getParent(),
|
||
CommonUtils.getFileNameWithoutExtension(program) + ".DVMH." +
|
||
(projectLanguage.equals(LanguageName.fortran) ? "f" : "c")
|
||
).toFile();
|
||
String command =
|
||
CommonUtils.DQuotes(server_dvm_drv) + " " +
|
||
projectLanguage.getDVMCompile() + "dv " +
|
||
options + " "
|
||
+ CommonUtils.DQuotes(program.getName());
|
||
//--
|
||
File fileWorkspace = program.getParentFile();
|
||
Process process = Utils.startScript(workspace, fileWorkspace, CommonUtils.getDateName("convert_script"), command);
|
||
process.waitFor();
|
||
String convertationOut = Utils.readAllOutput(process);
|
||
convertationOut = convertationOut.replace(program.getName(), fileName); //для учета пути.
|
||
if (!convertationOut.isEmpty())
|
||
output += convertationOut + "\n";
|
||
try {
|
||
if (convertedProgram.exists()) {
|
||
FileUtils.forceDelete(program);
|
||
convertedProgram.renameTo(program);
|
||
} else badFiles.add(program.getName());
|
||
} catch (Exception ex) {
|
||
ex.printStackTrace();
|
||
}
|
||
//--
|
||
}
|
||
response.arg = String.join("\n", badFiles) + "|" + output;
|
||
File resultArchive = new File(workspace, projectName + "_result.zip");
|
||
if (ComponentsServer.zip.Do(project.getAbsolutePath(), resultArchive.getAbsolutePath())) {
|
||
response.object = CommonUtils.fileToBytes(resultArchive);
|
||
} else
|
||
throw new RepositoryRefuseException("Внутренняя ошибка. Не удалось запаковать версию");
|
||
//--
|
||
} else
|
||
throw new RepositoryRefuseException("Внутренняя ошибка. Не удалось распаковать проект");
|
||
break;
|
||
}
|
||
} else
|
||
response = new ServerExchangeUnit_2021(ServerCode.OLD);
|
||
}
|
||
@Override
|
||
protected void startAdditionalThreads() {
|
||
backUp.start();
|
||
}
|
||
public static ZipFolderPass zip = new ZipFolderPass();
|
||
public static UnzipFolderPass unzip = new UnzipFolderPass();
|
||
public static ArchivesBackupPass backupSession = new ArchivesBackupPass();
|
||
//-
|
||
public static Vector<Pair<Machine, User>> storages =
|
||
new Vector<>(Arrays.asList(
|
||
new Pair<>(
|
||
new Machine("titan", "dvmh.keldysh.ru", 22, MachineType.Server),
|
||
new User("dvmuser1", "mprit_2011"))
|
||
/*
|
||
new Pair<>(
|
||
new Machine("k100", "k100.kiam.ru", 22, MachineType.Server),
|
||
new User("dvmuser1", "mprit_2011"))
|
||
*/
|
||
)
|
||
);
|
||
//-
|
||
protected Thread backUp = new Thread(() -> {
|
||
while (true) {
|
||
try {
|
||
//-------------------------------------
|
||
Calendar rightNow = Calendar.getInstance();
|
||
int year = rightNow.get(Calendar.YEAR);
|
||
int month = rightNow.get(Calendar.MONTH);
|
||
int day = rightNow.get(Calendar.DAY_OF_MONTH);
|
||
int hour = rightNow.get(Calendar.HOUR_OF_DAY);
|
||
int minute = rightNow.get(Calendar.MINUTE);
|
||
if ((hour == Global.properties.BackupHour) && (minute == Global.properties.BackupMinute)) {
|
||
//определить имя папки с багом.
|
||
String backUpName = year + "_" + (month + 1) + "_" + (day);
|
||
File todayBackUp = Paths.get(Global.DataBackUpsDirectory.getAbsolutePath(), backUpName).toFile();
|
||
File todayBackUpArchive = Paths.get(Global.DataBackUpsDirectory.getAbsolutePath(), backUpName + ".zip").toFile();
|
||
//-
|
||
File bugsDBBackUp = Paths.get(todayBackUp.getAbsolutePath(), db.getFile().getName()).toFile();
|
||
File bugsArchives = Paths.get(todayBackUp.getAbsolutePath(), "Bugs.zip").toFile();
|
||
//-
|
||
// Чистка старых бекапов на самом сервере.
|
||
Utils.keepNewFiles(todayBackUp.getParentFile(), 2);
|
||
if (!todayBackUpArchive.exists()) {
|
||
FileUtils.forceMkdir(todayBackUp);
|
||
Files.copy(db.getFile().toPath(), bugsDBBackUp.toPath());
|
||
//-
|
||
zip.Do("Bugs", bugsArchives.getAbsolutePath());
|
||
zip.Do(todayBackUp.getAbsolutePath(), todayBackUpArchive.getAbsolutePath());
|
||
Utils.forceDeleteWithCheck(todayBackUp);
|
||
//-
|
||
for (Pair<Machine, User> cred : storages) {
|
||
backupSession.Do(cred.getKey(), cred.getValue(),
|
||
todayBackUpArchive
|
||
);
|
||
}
|
||
//bonus backup
|
||
if (rightNow.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY) {
|
||
EmailMessage message = new EmailMessage(
|
||
"db backup",
|
||
"копия баз данных журнала ошибок",
|
||
new Vector<>()
|
||
);
|
||
Email(message, db.getFile());
|
||
}
|
||
}
|
||
}
|
||
//-------------------------------------
|
||
Thread.sleep(60000);
|
||
} catch (Exception ex) {
|
||
CommonUtils.MainLog.PrintException(ex);
|
||
}
|
||
}
|
||
});
|
||
}
|