879 lines
28 KiB
C++
879 lines
28 KiB
C++
#if _WIN32
|
||
#define _WINSOCK_DEPRECATED_NO_WARNINGS
|
||
#define _CRT_SECURE_NO_WARNINGS
|
||
#include <ws2tcpip.h>
|
||
#include <Windows.h>
|
||
#else
|
||
#include <unistd.h>
|
||
#endif
|
||
|
||
#include <thread>
|
||
#include <iostream>
|
||
#include <string>
|
||
#include <algorithm>
|
||
#include <unordered_map>
|
||
#include <ctime>
|
||
#include <vector>
|
||
|
||
//build under linux
|
||
//g++ -O3 -std=c++17 checkUniq.cpp server.cpp -o Visualizer_2 -lpthread -lstdc++fs";
|
||
|
||
#if _WIN32
|
||
#include <filesystem>
|
||
#include <direct.h>
|
||
namespace fs = std::filesystem;
|
||
#define getcwd _getcwd
|
||
#else
|
||
//с++14 unix + -lstdc++fs
|
||
/*#include <experimental/filesystem>
|
||
namespace fs = std::experimental::filesystem;*/
|
||
//с++17 unix
|
||
#include <filesystem>
|
||
namespace fs = std::filesystem;
|
||
#include <unistd.h>
|
||
#endif
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <signal.h>
|
||
|
||
using namespace std;
|
||
|
||
#if _WIN32
|
||
//link with Ws2_32.lib
|
||
#pragma comment(lib, "Ws2_32.lib")
|
||
|
||
#define SPF_NAME "Components\\Sapfor_F.exe"
|
||
#define SPF_NAME_NEW "Components\\Sapfor_F_new.exe"
|
||
|
||
#define SPC_NAME "Components\\Sapfor_C.exe"
|
||
#define SPC_NAME_NEW "Components\\Sapfor_C_new.exe"
|
||
|
||
#define VIZ_NAME "Components\\VisualSapfor.jar"
|
||
#define VIZ_NAME_NEW "Components\\VisualSapfor_new.jar"
|
||
#define FILE_LOG "Components\\Server_log.txt"
|
||
|
||
#define SPF_ASYNC " "
|
||
#else
|
||
|
||
#include <sys/types.h>
|
||
#include <sys/socket.h>
|
||
#include <unistd.h>
|
||
#include <netinet/in.h>
|
||
#include <arpa/inet.h>
|
||
|
||
#define SOCKET int
|
||
#define INVALID_SOCKET (SOCKET)(~0)
|
||
#define SOCKADDR sockaddr
|
||
#define closesocket close
|
||
|
||
#define SPF_NAME "Components/Sapfor_F"
|
||
#define SPF_NAME_NEW "Components/Sapfor_F_new"
|
||
|
||
#define SPC_NAME "Components/Sapfor_C"
|
||
#define SPC_NAME_NEW "Components/Sapfor_C_new"
|
||
|
||
#define VIZ_NAME "Components/VisualSapfor.jar"
|
||
#define VIZ_NAME_NEW "Components/VisualSapfor_new.jar"
|
||
#define FILE_LOG "Components/Server_log.txt"
|
||
|
||
#define SPF_ASYNC "&"
|
||
|
||
void WSACleanup() { }
|
||
int WSAGetLastError() { return 0; }
|
||
void Sleep(int millisec) { usleep(millisec * 2000); }
|
||
|
||
#endif
|
||
|
||
#define __print(prefix, format, ...) do { } while (0)
|
||
|
||
#define __print_log(file, format, ...) do { } while (0)
|
||
/*
|
||
#define __print(prefix, format, ...) do {\
|
||
printf((string("%s: ") + format + string("\n")).c_str(), prefix, ##__VA_ARGS__); \
|
||
fflush(NULL); \
|
||
} while (0)
|
||
|
||
#define __print_log(file, format, ...) do {\
|
||
if (file) { \
|
||
time_t now = time(0);\
|
||
auto dt = string(ctime(&now)); \
|
||
dt = dt.erase(dt.size() - 1); \
|
||
fprintf(file, (string("%s: ") + format + string("\n")).c_str(), dt.c_str(), ##__VA_ARGS__); \
|
||
fflush(file); \
|
||
} \
|
||
} while (0)
|
||
*/
|
||
#define SERV "[SERVER]"
|
||
|
||
static const char* VERSION = "11";
|
||
static FILE* logFile = NULL;
|
||
|
||
extern void __bst_create(const char* name);
|
||
extern bool __bst_tryToLock();
|
||
extern void __bst_unlock();
|
||
|
||
|
||
static void signal_handler(int s)
|
||
{
|
||
__print(SERV, "Caught signal %d", s);
|
||
__bst_unlock();
|
||
exit(1);
|
||
}
|
||
|
||
static int getPort(const SOCKET& listenSocket)
|
||
{
|
||
sockaddr_in info;
|
||
socklen_t len = sizeof(info);
|
||
memset(&info, 0, len);
|
||
|
||
int err = getsockname(listenSocket, (sockaddr*)&info, &len);
|
||
if (err != 0)
|
||
{
|
||
__print(SERV, "Error of getaddrinfo(): %d", err);
|
||
WSACleanup();
|
||
__bst_unlock();
|
||
exit(1);
|
||
}
|
||
return ntohs(info.sin_port);
|
||
}
|
||
|
||
static int initServer(SOCKET& listenSocket, const string& address, int port = 0)
|
||
{
|
||
int iResult;
|
||
#if _WIN32
|
||
WSADATA wsaData = { 0 };
|
||
int resultc = WSAStartup(MAKEWORD(2, 0), &wsaData);
|
||
if (resultc != 0)
|
||
{
|
||
__print(SERV, "result of WSAStartup is %d", resultc);
|
||
return 1;
|
||
}
|
||
#endif
|
||
|
||
#if _WIN32
|
||
addrinfo* result = NULL, hints;
|
||
memset(&hints, 0, sizeof(hints));
|
||
hints.ai_family = AF_INET;
|
||
hints.ai_socktype = SOCK_STREAM;
|
||
hints.ai_protocol = IPPROTO_TCP;
|
||
hints.ai_flags = AI_PASSIVE;
|
||
|
||
iResult = getaddrinfo(address.c_str(), to_string(port).c_str(), &hints, &result);
|
||
if (iResult != 0)
|
||
{
|
||
__print(SERV, "Error of getaddrinfo(): %d", iResult);
|
||
WSACleanup();
|
||
return 1;
|
||
}
|
||
|
||
listenSocket = INVALID_SOCKET;
|
||
listenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
|
||
#else
|
||
listenSocket = socket(AF_INET, SOCK_STREAM, 0);
|
||
#endif
|
||
if (listenSocket < 0)
|
||
{
|
||
__print(SERV, "Error of socket(): %d", listenSocket);
|
||
WSACleanup();
|
||
return 1;
|
||
}
|
||
|
||
linger lin;
|
||
lin.l_onoff = 1;
|
||
lin.l_linger = 2;
|
||
iResult = setsockopt(listenSocket, SOL_SOCKET, SO_LINGER, (char*)(&lin), sizeof(lin));
|
||
if (iResult != 0)
|
||
{
|
||
__print(SERV, "Error of setsockopt(): %d", iResult);
|
||
return 1;
|
||
}
|
||
|
||
|
||
#if _WIN32
|
||
iResult = bind(listenSocket, result->ai_addr, result->ai_addrlen);
|
||
#else
|
||
sockaddr_in addr;
|
||
addr.sin_family = AF_INET;
|
||
addr.sin_port = htons(port);
|
||
addr.sin_addr.s_addr = htonl(INADDR_ANY);
|
||
|
||
iResult = ::bind(listenSocket, (struct sockaddr*) & addr, sizeof(addr));
|
||
#endif
|
||
if (iResult < 0)
|
||
{
|
||
__print(SERV, "Bind failed with error: %d", iResult);
|
||
closesocket(listenSocket);
|
||
WSACleanup();
|
||
return 1;
|
||
}
|
||
|
||
iResult = listen(listenSocket, 1);
|
||
if (iResult < 0)
|
||
{
|
||
__print(SERV, "Listen failed with error: %d", iResult);
|
||
closesocket(listenSocket);
|
||
WSACleanup();
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static int initClient(SOCKET& javaSocket, const string& address, int port)
|
||
{
|
||
javaSocket = socket(AF_INET, SOCK_STREAM, 0);
|
||
|
||
if (javaSocket == INVALID_SOCKET)
|
||
{
|
||
__print(SERV, "Error of creating java socket");
|
||
return -1;
|
||
}
|
||
|
||
linger lin;
|
||
lin.l_onoff = 1;
|
||
lin.l_linger = 2;
|
||
int iResult = setsockopt(javaSocket, SOL_SOCKET, SO_LINGER, (char*)(&lin), sizeof(lin));
|
||
if (iResult != 0)
|
||
{
|
||
__print(SERV, "Error of setsockopt(): %d", iResult);
|
||
return 1;
|
||
}
|
||
|
||
sockaddr_in clientService;
|
||
clientService.sin_family = AF_INET;
|
||
clientService.sin_addr.s_addr = inet_addr(address.c_str());
|
||
clientService.sin_port = htons(port);
|
||
int result = connect(javaSocket, (SOCKADDR*)(&clientService), sizeof(clientService));
|
||
|
||
if (result != 0)
|
||
__print(SERV, "Error %d of connect to socket %s: %d", WSAGetLastError(), address.c_str(), port);
|
||
|
||
return result;
|
||
}
|
||
|
||
static volatile bool spfRun = false;
|
||
static volatile int retCodeF = 0;
|
||
static void runSapfor(const string command)
|
||
{
|
||
spfRun = true;
|
||
__print("[SERVER-th1]", "Try to start Sapfor");
|
||
__print_log(logFile, "Try to start Sapfor");
|
||
retCodeF = 0;
|
||
retCodeF = system(command.c_str());
|
||
__print("[SERVER-th1]", "SAPFOR done with exit code %d", retCodeF);
|
||
__print_log(logFile, "SAPFOR done with exit code %d", retCodeF);
|
||
spfRun = false;
|
||
}
|
||
|
||
static volatile bool spcRun = false;
|
||
static volatile int retCodeC = 0;
|
||
static void runSapforC(const string command)
|
||
{
|
||
spcRun = true;
|
||
__print("[SERVER-th3]", "Try to start Sapfor(C)");
|
||
__print_log(logFile, "Try to start Sapfor(C)");
|
||
retCodeC = 0;
|
||
retCodeC = system(command.c_str());
|
||
__print("[SERVER-th3]", "SAPFOR(C) done with exit code %d", retCodeC);
|
||
__print_log(logFile, "SAPFOR(C) done with exit code %d", retCodeC);
|
||
spcRun = false;
|
||
}
|
||
|
||
static volatile bool vizRun = false;
|
||
static void runVisulizer(const string command)
|
||
{
|
||
vizRun = true;
|
||
__print("[SERVER-th2]", "Try to start Visualizer");
|
||
__print_log(logFile, "Try to start Visualizer");
|
||
int id = system(command.c_str());
|
||
__print("[SERVER-th2]", "Visualizer done with exit code %d", id);
|
||
__print_log(logFile, "Visualizer done with exit code %d", id);
|
||
vizRun = false;
|
||
}
|
||
|
||
static bool doCommand(SOCKET& spfSoc, SOCKET& javaSoc, SOCKET& serverSoc1, SOCKET& serverSoc2, const string& command, bool& needToUpdateViz, string &returnToJava)
|
||
{
|
||
if (command.find("restart:") == 0)
|
||
{
|
||
__print(SERV, "Restart SAPFOR");
|
||
closesocket(spfSoc);
|
||
spfSoc = INVALID_SOCKET;
|
||
|
||
//wait shutdown of spf
|
||
while (spfRun)
|
||
;
|
||
|
||
return true;
|
||
}
|
||
else if (command.find("close:") == 0)
|
||
{
|
||
__print(SERV, "Shutdown");
|
||
closesocket(spfSoc);
|
||
closesocket(javaSoc);
|
||
closesocket(serverSoc1);
|
||
closesocket(serverSoc2);
|
||
javaSoc = spfSoc = INVALID_SOCKET;
|
||
|
||
Sleep(500);
|
||
__bst_unlock();
|
||
exit(0);
|
||
}
|
||
else if (command.find("update:") == 0)
|
||
{
|
||
__print(SERV, "Update Visualizer");
|
||
closesocket(spfSoc);
|
||
closesocket(javaSoc);
|
||
javaSoc = spfSoc = INVALID_SOCKET;
|
||
|
||
//wait shutdown of viz
|
||
while (vizRun)
|
||
;
|
||
|
||
//copy new version
|
||
if (fs::exists(VIZ_NAME_NEW))
|
||
{
|
||
int countOf = 0;
|
||
error_code err;
|
||
do {
|
||
++countOf;
|
||
fs::copy_file(VIZ_NAME_NEW, VIZ_NAME, fs::copy_options::overwrite_existing, err);
|
||
__print(SERV, "Updated with error code %d: %s", err.value(), err.message().c_str());
|
||
if (err.value() != 0)
|
||
std::this_thread::sleep_for(std::chrono::milliseconds(200));
|
||
} while (err.value() != 0 && countOf < 5);
|
||
}
|
||
else
|
||
__print(SERV, "Can not find new version of Visualizer in '%s' path", VIZ_NAME_NEW);
|
||
//restart
|
||
needToUpdateViz = true;
|
||
return true;
|
||
}
|
||
else if (command.find("update_spf:") == 0)
|
||
{
|
||
__print(SERV, "Update SAPFOR");
|
||
closesocket(spfSoc);
|
||
spfSoc = INVALID_SOCKET;
|
||
|
||
//wait shutdown of spf
|
||
while (spfRun)
|
||
;
|
||
//copy new version
|
||
if (fs::exists(SPF_NAME_NEW))
|
||
{
|
||
int countOf = 0;
|
||
error_code err;
|
||
do {
|
||
++countOf;
|
||
fs::copy_file(SPF_NAME_NEW, SPF_NAME, fs::copy_options::overwrite_existing, err);
|
||
__print(SERV, "Updated with error code %d: %s", err.value(), err.message().c_str());
|
||
if (err.value() != 0)
|
||
std::this_thread::sleep_for(std::chrono::milliseconds(200));
|
||
} while (err.value() != 0 && countOf < 5);
|
||
}
|
||
else
|
||
__print(SERV, "Can not find new version of sapfor in '%s' path", SPF_NAME_NEW);
|
||
//restart
|
||
return true;
|
||
}
|
||
else if (command.find("update_spc:") == 0)
|
||
{
|
||
__print(SERV, "Update SAPFOR");
|
||
closesocket(spfSoc);
|
||
spfSoc = INVALID_SOCKET;
|
||
|
||
//wait shutdown of spc
|
||
while (spcRun)
|
||
;
|
||
//copy new version
|
||
if (fs::exists(SPC_NAME_NEW))
|
||
{
|
||
int countOf = 0;
|
||
error_code err;
|
||
do {
|
||
++countOf;
|
||
fs::copy_file(SPC_NAME_NEW, SPC_NAME, fs::copy_options::overwrite_existing, err);
|
||
__print(SERV, "Updated with error code %d: %s", err.value(), err.message().c_str());
|
||
if (err.value() != 0)
|
||
std::this_thread::sleep_for(std::chrono::milliseconds(200));
|
||
} while (err.value() != 0 && countOf < 5);
|
||
}
|
||
else
|
||
__print(SERV, "Can not find new version of sapfor in '%s' path", SPC_NAME_NEW);
|
||
//restart
|
||
return true;
|
||
}
|
||
else if (command.find("update_server:") == 0)
|
||
{
|
||
__print(SERV, "Update SERVER");
|
||
closesocket(spfSoc);
|
||
spfSoc = INVALID_SOCKET;
|
||
|
||
//wait shutdown of spf
|
||
while (spfRun)
|
||
;
|
||
|
||
//wait shutdown of spc
|
||
while (spcRun)
|
||
;
|
||
|
||
closesocket(javaSoc);
|
||
javaSoc = INVALID_SOCKET;
|
||
__print(SERV, "SAPFOR was closed, Visualizer socker was closed, exit");
|
||
|
||
Sleep(500);
|
||
__bst_unlock();
|
||
exit(0);
|
||
}
|
||
else if (command.find("get_version:") == 0)
|
||
{
|
||
__print(SERV, "Get version of server: %s", VERSION);
|
||
returnToJava = string(VERSION) + " |" + __DATE__ + "| |" + __TIME__ + "|\n";
|
||
return true;
|
||
}
|
||
else if (command.find("get_pid:") == 0)
|
||
{
|
||
unsigned int pid = 0;
|
||
#ifdef _WIN32
|
||
pid = GetCurrentProcessId();
|
||
#else
|
||
pid = getpid();
|
||
#endif
|
||
const string pids = std::to_string(pid);
|
||
__print(SERV, "Get pid of server: %s", pids.c_str());
|
||
returnToJava = pids + "\n";
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
string copy = command;
|
||
if (copy.back() == '\n')
|
||
copy = copy.erase(copy.size() - 1);
|
||
__print(SERV, "Recv command %s", copy.c_str());
|
||
}
|
||
return false;
|
||
}
|
||
|
||
static void closeAndExit(const vector<SOCKET>& toClose, const string& message, int exitCode = 0)
|
||
{
|
||
for (auto& elem : toClose)
|
||
closesocket(elem);
|
||
if (message != "")
|
||
__print(SERV, "%s", message.c_str());
|
||
__bst_unlock();
|
||
exit(exitCode);
|
||
}
|
||
|
||
static bool isSapforDebug(int argc, char** argv)
|
||
{
|
||
for (int z = 1; z < argc; ++z)
|
||
if (string("-spfDeb") == argv[z])
|
||
return true;
|
||
return false;
|
||
}
|
||
|
||
static bool isVizDebug(int argc, char** argv)
|
||
{
|
||
for (int z = 1; z < argc; ++z)
|
||
if (string("-vizDeb") == argv[z])
|
||
return true;
|
||
return false;
|
||
}
|
||
|
||
static string getJavaPath(int argc, char** argv)
|
||
{
|
||
string path = "";
|
||
for (int z = 1; z < argc; ++z)
|
||
if (string("-javaPath") == argv[z])
|
||
return argv[z + 1];
|
||
|
||
return path;
|
||
}
|
||
|
||
static int doRecv(SOCKET& soc, string& command)
|
||
{
|
||
int count = 0; //общее количество прочитаного
|
||
int err = 0; //количество прочитанного на данной итерации.
|
||
const int maxSize = 4096; //максимальный размер прочитываемой за раз порции.
|
||
char* buf = NULL; //буфер
|
||
do
|
||
{
|
||
buf = new char[maxSize + 1];
|
||
err = recv(soc, buf, maxSize, 0);
|
||
if (err > 0)
|
||
{
|
||
count += err;
|
||
buf[err] = '\0';
|
||
command += buf;
|
||
}
|
||
delete[] buf;
|
||
buf = NULL;
|
||
|
||
} while (err > 0 && command.back() != '\n');
|
||
__print(SERV, "'%s' length='%d'\n", command.c_str(), command.length());
|
||
return err < 0 ? err : count;
|
||
}
|
||
|
||
int main(int argc, char** argv)
|
||
{
|
||
if (argc == 2 && argv[1] == string("-help"))
|
||
{
|
||
printf("commands:\n");
|
||
printf(" -hashSkip\n");
|
||
printf(" -unlock\n");
|
||
printf(" -javaPath <path>\n");
|
||
exit(0);
|
||
}
|
||
|
||
signal(SIGINT, signal_handler);
|
||
signal(SIGABRT, signal_handler);
|
||
#if _WIN32
|
||
signal(SIGBREAK, signal_handler);
|
||
#else
|
||
signal(SIGKILL, signal_handler);
|
||
#endif
|
||
|
||
char buff[1024];
|
||
char* test = getcwd(buff, 1024);
|
||
|
||
const string path = test ? buff : argv[0];
|
||
bool isSpfDeb = isSapforDebug(argc, argv);
|
||
bool isVizDeb = isVizDebug(argc, argv);
|
||
string javaPath = getJavaPath(argc, argv);
|
||
|
||
if (argc == 2 && argv[1] == string("-hashSkip"))
|
||
;
|
||
else
|
||
{
|
||
const size_t hashOfPath = hash<string>{}(path);
|
||
__print(SERV, "Open or create mutex of '%s' path, hash = %zu", path.c_str(), hashOfPath);
|
||
|
||
__bst_create(to_string(hashOfPath).c_str());
|
||
if (argc == 2 && argv[1] == string("-unlock"))
|
||
{
|
||
if (!__bst_tryToLock())
|
||
{
|
||
__print(SERV, "Try to unlock '%s' path", path.c_str());
|
||
__bst_unlock();
|
||
exit(0);
|
||
}
|
||
}
|
||
|
||
if (!__bst_tryToLock())
|
||
{
|
||
__print(SERV, "The instance of Visualizer from '%s' path was started", path.c_str());
|
||
exit(0);
|
||
}
|
||
}
|
||
logFile = fopen(FILE_LOG, "w");
|
||
if (logFile == NULL)
|
||
__print(SERV, "Can not open log file '%s'", FILE_LOG);
|
||
|
||
setlocale(LC_ALL, "Russian");
|
||
SOCKET serverSPF = INVALID_SOCKET, serverJAVA = INVALID_SOCKET;
|
||
int sapforPort = 0, javaPort = 0;
|
||
|
||
__print_log(logFile, "create socket for Sapfor");
|
||
if (initServer(serverSPF, "127.0.0.1", sapforPort) != 0) // create server for Sapfor
|
||
return -1;
|
||
sapforPort = getPort(serverSPF);
|
||
__print_log(logFile, "done with port %d", sapforPort);
|
||
|
||
__print_log(logFile, "create socket for Visualizer");
|
||
if (initServer(serverJAVA, "127.0.0.1", javaPort) != 0) // create server for Visuzlier
|
||
{
|
||
closesocket(serverSPF);
|
||
return -1;
|
||
}
|
||
javaPort = getPort(serverJAVA);
|
||
__print_log(logFile, "done with port %d", javaPort);
|
||
|
||
printf("SOCKET PORT for SAPFOR %d, SOCKET PORT for Visualizer %d\n", sapforPort, javaPort);
|
||
|
||
const int maxSize = 4096;
|
||
char* buf = new char[maxSize + 1];
|
||
|
||
int err;
|
||
|
||
SOCKET spfSoc = INVALID_SOCKET, javaSoc = INVALID_SOCKET;
|
||
bool needToUpdateViz = true;
|
||
int t = 0;
|
||
|
||
__print_log(logFile, "start main communications");
|
||
while (true)
|
||
{
|
||
if (!vizRun && needToUpdateViz && !isVizDeb)
|
||
{
|
||
__print_log(logFile, "try to restart Visualizer, flags before: vizRun(%d), needToUpdateViz(%d), isVizDeb(%d)",
|
||
vizRun, needToUpdateViz, isVizDeb);
|
||
|
||
__print(SERV, "Run Visualizer from '%s' path with port %d", VIZ_NAME, javaPort);
|
||
if (fs::exists(VIZ_NAME))
|
||
{
|
||
needToUpdateViz = false;
|
||
string toRun = string("-Dfile.encoding=UTF-8 -jar ") + VIZ_NAME + " --port " + to_string(javaPort) + SPF_ASYNC;
|
||
if (javaPath != "")
|
||
toRun = "\"" + javaPath + "\\java\" " + toRun;
|
||
else
|
||
toRun = "java " + toRun;
|
||
|
||
__print_log(logFile, "try to start with command '%s'", toRun.c_str());
|
||
|
||
thread viz(runVisulizer, toRun);
|
||
viz.detach();
|
||
|
||
__print_log(logFile, "done");
|
||
//wait run of viz
|
||
//while (!vizRun) ;
|
||
}
|
||
else
|
||
{
|
||
__print(SERV, "Can not find Visualizer in '%s' path", VIZ_NAME);
|
||
__print_log(logFile, "Can not find Visualizer in '%s' path", VIZ_NAME);
|
||
//closeAndExit({ serverSPF , serverJAVA }, "Component not found", -1);
|
||
}
|
||
}
|
||
|
||
if (!spfRun && !isSpfDeb)
|
||
{
|
||
__print_log(logFile, "try to restart Sapfor, flags before: spfRun(%d), isSpfDeb(%d)",
|
||
spfRun, isSpfDeb);
|
||
|
||
__print(SERV, "Run Sapfor from '%s' path with port %d", SPF_NAME, sapforPort);
|
||
if (fs::exists(SPF_NAME))
|
||
{
|
||
const string toRun = SPF_NAME + string(" -client ") + to_string(sapforPort) + SPF_ASYNC;
|
||
__print_log(logFile, "try to start with command '%s'", toRun.c_str());
|
||
|
||
thread sapfor(runSapfor, toRun);
|
||
sapfor.detach();
|
||
|
||
__print_log(logFile, "done");
|
||
//wait run of spf
|
||
//while (!spfRun) ;
|
||
}
|
||
else
|
||
{
|
||
__print(SERV, "Can not find Sapfor in '%s' path", SPF_NAME);
|
||
__print_log(logFile, "Can not find Sapfor in '%s' path", SPF_NAME);
|
||
//closeAndExit({ serverSPF , serverJAVA }, "Component not found", -1);
|
||
}
|
||
}
|
||
|
||
bool spfExists = (fs::exists(SPF_NAME) || isSpfDeb);
|
||
|
||
__print_log(logFile, "start connections");
|
||
|
||
for (int z = 0; z < 2; ++z)
|
||
{
|
||
if (javaSoc == INVALID_SOCKET && z == 1)
|
||
{
|
||
__print_log(logFile, "wait acception from Visualizer");
|
||
javaSoc = accept(serverJAVA, NULL, NULL);
|
||
if (javaSoc != INVALID_SOCKET)
|
||
{
|
||
__print(SERV, "VISUALIZER connected to server");
|
||
__print_log(logFile, "VISUALIZER connected to server");
|
||
}
|
||
}
|
||
|
||
if (spfSoc == INVALID_SOCKET && z == 0 && spfExists)
|
||
{
|
||
__print_log(logFile, "wait acception from Sapfor");
|
||
spfSoc = accept(serverSPF, NULL, NULL);
|
||
if (spfSoc != INVALID_SOCKET)
|
||
{
|
||
__print(SERV, "SAPFOR connected to server");
|
||
__print_log(logFile, "SAPFOR connected to server");
|
||
}
|
||
}
|
||
}
|
||
__print_log(logFile, "done connections");
|
||
|
||
while ( ((spfSoc != INVALID_SOCKET && spfExists) || (!fs::exists(SPF_NAME) && !isSpfDeb)) &&
|
||
javaSoc != INVALID_SOCKET)
|
||
{
|
||
string retCode = "";
|
||
string command = "";
|
||
|
||
__print_log(logFile, "wait for command from Visualizer");
|
||
err = doRecv(javaSoc, command);
|
||
__print_log(logFile, "done with code %d", err);
|
||
if (err <= 0)
|
||
{
|
||
__print(SERV, "Error recv from Visualizer with code %d", err);
|
||
__print_log(logFile, "error recv from Visualizer with code %d", err);
|
||
closesocket(javaSoc);
|
||
closesocket(spfSoc);
|
||
javaSoc = spfSoc = INVALID_SOCKET;
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
string returnToJava = "";
|
||
__print_log(logFile, "do command '%s'", command.c_str());
|
||
if (doCommand(spfSoc, javaSoc, serverSPF, serverJAVA, command, needToUpdateViz, returnToJava))
|
||
{
|
||
if (javaSoc != INVALID_SOCKET)
|
||
{
|
||
int needToRecv = 1;
|
||
if (returnToJava == "")
|
||
buf[0] = '\n';
|
||
else
|
||
{
|
||
memcpy(buf, returnToJava.c_str(), sizeof(char) * returnToJava.size());
|
||
needToRecv = returnToJava.size();
|
||
}
|
||
|
||
int err = send(javaSoc, buf, needToRecv, 0);
|
||
if (err != needToRecv)
|
||
{
|
||
closesocket(javaSoc);
|
||
javaSoc = INVALID_SOCKET;
|
||
__print_log(logFile, "done with invalid break ");
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
//after 'get_version' command
|
||
if (needToRecv > 1)
|
||
{
|
||
__print_log(logFile, "done with continue");
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
__print_log(logFile, "done with break");
|
||
break;
|
||
}
|
||
__print_log(logFile, "done");
|
||
}
|
||
|
||
__print_log(logFile, "try to send command to Sapfor with size %d", command.size());
|
||
err = send(spfSoc, command.c_str(), command.size(), 0);
|
||
__print_log(logFile, "done with code %d", err);
|
||
|
||
if (err != command.size())
|
||
{
|
||
__print(SERV, "Error of send(): %d", err);
|
||
__print_log(logFile, "error of send(): %d", err);
|
||
closesocket(spfSoc);
|
||
spfSoc = INVALID_SOCKET;
|
||
}
|
||
else
|
||
__print(SERV, "Send command to SAPFOR");
|
||
|
||
__print_log(logFile, "try to recv answer from Sapfor");
|
||
err = recv(spfSoc, buf, maxSize, 0);
|
||
__print_log(logFile, "done with code %d", err);
|
||
|
||
int sizeLong = -1;
|
||
char* bufLong = NULL;
|
||
|
||
if (err <= 0)
|
||
{
|
||
__print(SERV, "Error recv(): %d", err);
|
||
__print_log(logFile, "error recv(): %d", err);
|
||
closesocket(spfSoc);
|
||
spfSoc = INVALID_SOCKET;
|
||
|
||
if (spfRun)
|
||
retCode = "WRONG\n";
|
||
else
|
||
{
|
||
if (fs::exists(SPF_NAME))
|
||
{
|
||
if (retCodeF != 0)
|
||
retCode = "SIG_FAULT\n";
|
||
else
|
||
retCode = "WRONG\n";
|
||
}
|
||
else
|
||
retCode = "NOT_FOUND\n";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (err >= maxSize)
|
||
closeAndExit({ spfSoc , javaSoc , serverSPF , serverJAVA }, "Critical error", -1);
|
||
|
||
buf[err] = '\0';
|
||
err = sscanf(buf, "%d", &sizeLong);
|
||
if (err == -1)
|
||
closeAndExit({ spfSoc , javaSoc , serverSPF , serverJAVA }, "Critical error", -1);
|
||
|
||
bufLong = (char*)malloc(sizeof(char) * (sizeLong + 1));
|
||
if (bufLong == NULL)
|
||
{
|
||
__print(SERV, "Error in malloc, exit, need to alloc %d", sizeLong + 1);
|
||
closeAndExit({ spfSoc , javaSoc , serverSPF , serverJAVA }, "", -1);
|
||
}
|
||
}
|
||
|
||
if (retCode.find("WRONG") == string::npos &&
|
||
retCode.find("NOT_FOUND") == string::npos &&
|
||
retCode.find("SIG_FAULT") == string::npos)
|
||
{
|
||
retCode = "";
|
||
err = send(spfSoc, buf, 1, 0);
|
||
int start = 0;
|
||
int sum = 0;
|
||
while (sum != sizeLong)
|
||
{
|
||
__print_log(logFile, "try to recv results from Sapfor");
|
||
err = recv(spfSoc, bufLong + start, sizeLong - sum, 0);
|
||
__print_log(logFile, "done with code %d", err);
|
||
if (err <= 0)
|
||
{
|
||
__print(SERV, "Error of recv from SAPFOR with code %d", err);
|
||
__print_log(logFile, "error of recv from SAPFOR with code %d", err);
|
||
retCode = "WRONG\n";
|
||
closesocket(spfSoc);
|
||
spfSoc = INVALID_SOCKET;
|
||
break;
|
||
}
|
||
else
|
||
__print(SERV, "Recv from SAPFOR result == %d size, request size %d", err, sizeLong - sum);
|
||
sum += err;
|
||
start += err;
|
||
}
|
||
__print(SERV, "Recv from SAPFOR total %d size", sum);
|
||
__print_log(logFile, "done recv from SAPFOR with total %d size", sum);
|
||
|
||
if (sum >= sizeLong + 1)
|
||
closeAndExit({ spfSoc , javaSoc , serverSPF , serverJAVA }, "Critical error", -1);
|
||
|
||
bufLong[sum] = '\0';
|
||
retCode = bufLong;
|
||
free(bufLong);
|
||
}
|
||
else
|
||
__print(SERV, "Send error code to Visualizer: %s", retCode.c_str());
|
||
|
||
__print_log(logFile, "send response to Sapfor");
|
||
err = send(spfSoc, buf, 1, 0);
|
||
__print_log(logFile, "done with code %d", err);
|
||
|
||
__print_log(logFile, "send response to Visualizer");
|
||
err = send(javaSoc, retCode.c_str(), retCode.size(), 0);
|
||
__print_log(logFile, "done with code %d", err);
|
||
if (err != retCode.size())
|
||
{
|
||
__print(SERV, "Error send to Visualizer");
|
||
__print_log(logFile, "error send to Visualizer");
|
||
closesocket(spfSoc);
|
||
closesocket(javaSoc);
|
||
javaSoc = spfSoc = INVALID_SOCKET;
|
||
break;
|
||
}
|
||
else
|
||
__print(SERV, "Send result to Visualizer %d", (int)retCode.size());
|
||
}
|
||
__print(SERV, "Invalid SAPFOR socket, try to restart");
|
||
__print_log(logFile, "invalid SAPFOR socket, try to restart");
|
||
Sleep(100);
|
||
}
|
||
|
||
__bst_unlock();
|
||
return 0;
|
||
}
|
||
|