private MessageFromServerToClient HandleRequestForJob([NotNull] MessageFromClientToServer req)
{
if (OpenTasks.IsEmpty)
{
return(new MessageFromServerToClient(ServerResponseEnum.NothingToDo, req.TaskGuid));
}
bool success = OpenTasks.TryDequeue(out var task);
if (success)
{
SaveExecuteHelper.Get().SaveExecuteWithWait(() => ActiveTasks.Add(task));
task.Client = req.ClientName;
task.ExecutionStart = DateTime.Now;
var answer = new MessageFromServerToClient(ServerResponseEnum.ServeCalcJob, task.Guid);
answer.HouseJobStr = File.ReadAllText(task.OriginalJsonFilePath ??
throw new DistSimException("Jsonpath was not found: " + task.OriginalJsonFilePath));
FileInfo fi = new FileInfo(task.OriginalJsonFilePath);
answer.OriginalFileName = fi.Name;
answer.LpgFiles = InitalizeLpgFiles(false);
return(answer);
}
return(new MessageFromServerToClient(ServerResponseEnum.NothingToDo, req.TaskGuid));
}
private MessageFromClientToServer PrepareMessageFromClient(ClientRequestEnum status, [NotNull] string message)
{
var em = new MessageFromClientToServer(status, _threadId.Name, message, Guid.NewGuid().ToString());
_logger.Info("Preparing request: " + status + " " + message, _threadId);
return(em);
}
private MessageFromServerToClient HandleDiskFullReport([NotNull] MessageFromClientToServer req)
{
try {
_logger.Info(req.ClientName + " reports disk full", _threadId);
return(new MessageFromServerToClient(ServerResponseEnum.NothingToDo, Guid.NewGuid().ToString()));
}
catch (Exception ex) {
_logger.Exception(ex, "handing disk full report");
throw;
}
}
private void ReportFinishedCalcJob([NotNull] MessageFromServerToClient job,
[NotNull] RequestSocket client,
[CanBeNull] HouseCreationAndCalculationJob hcj)
{
var msg = new MessageFromClientToServer(ClientRequestEnum.ReportFinish, _threadId.Name, "finished calculation", job.TaskGuid);
if (hcj != null)
{
msg.Scenario = hcj.Scenario;
msg.Year = hcj.Year;
msg.Trafokreis = hcj.Trafokreis;
msg.HouseName = hcj.House?.Name;
}
string resultDirectory = Path.Combine(_mySettings.ClientSettings.LPGCalcDirectory, "Results");
DirectoryInfo di = new DirectoryInfo(resultDirectory);
if (di.Exists)
{
var files = di.GetFiles("*.*", SearchOption.AllDirectories);
var filteredFiles = new List <FileInfo>();
foreach (var file in files)
{
if (file.Name.ToLower(CultureInfo.InvariantCulture).EndsWith(".dat"))
{
_logger.Error("Refusing dat file: " + file.FullName, _threadId);
continue;
}
if (file.Length > 100_000_000)
{
_logger.Error("Refusing too big file: " + file.FullName, _threadId);
continue;
}
filteredFiles.Add(file);
}
msg.ResultFiles = MsgFile.ReadMsgFiles(true, filteredFiles, di, _logger, _threadId);
var reportAnswer = MakeRequest(client, msg);
_logger.Info("Answer from the finish report:" + reportAnswer.ServerResponse, _threadId);
}
else
{
_logger.Info("No output directory created, reporting failure to the server", _threadId);
var msg2 = new MessageFromClientToServer(ClientRequestEnum.ReportFailure,
_threadId.Name,
"result directory is missing",
job.TaskGuid);
var reportAnswer = MakeRequest(client, msg2);
_logger.Info("Answer from the finish report:" + reportAnswer.ServerResponse, _threadId);
}
}
private MessageFromServerToClient HandleRequestForLpgFiles([NotNull] MessageFromClientToServer req)
{
_logger.Info("trying to collect lpg files for " + req.ClientName, _threadId);
try {
MessageFromServerToClient answer = new MessageFromServerToClient(ServerResponseEnum.ServeLpgFiles, req.TaskGuid);
answer.LpgFiles = InitalizeLpgFiles(true);
_logger.Info("sending lpg files to client " + req.ClientName + " total files", _threadId);
return(answer);
}
catch (Exception ex) {
_logger.Exception(ex, "Trying to collect files");
throw;
}
}
private MessageFromServerToClient HandleFailureReport([NotNull] MessageFromClientToServer req)
{
var task = ActiveTasks.FirstOrDefault(x => x.Guid == req.TaskGuid);
if (task == null)
{
throw new DistSimException("Invalid guid: " + req.TaskGuid);
}
task.FinishStatusMessage = req.ClientRequest + " " + req.Message;
SaveExecuteHelper.Get().SaveExecuteWithWait(() => ActiveTasks.Remove(task));
SaveExecuteHelper.Get().SaveExecuteWithWait(() => FinishedTasks.Add(task));
_errorLogger.Error(task.OriginalJsonFilePath + " - no output at all at client " + req.ClientName, _threadId);
Logger.Error(task.OriginalJsonFilePath + " - no output at all at client " + req.ClientName, _threadId);
return(new MessageFromServerToClient(ServerResponseEnum.JobFinishAck, req.TaskGuid));
}
public void TrackLastRequest([NotNull] MessageFromClientToServer req)
{
string cleanname = CleanClientName(req.ClientName);
var client = ClientStatus.FirstOrDefault(x => x.ClientName == cleanname);
if (client == null)
{
client = new ServerClientStatusTracker(cleanname);
SaveExecuteHelper.Get().SaveExecuteWithWait(() => ClientStatus.Add(client));
}
if (req.ClientRequest == ClientRequestEnum.ReportFinish)
{
client.CompletedJobs++;
}
if (req.ClientRequest == ClientRequestEnum.ReportFailure)
{
client.FailedJobs++;
}
client.LastRequestTime = DateTime.Now;
client.LastRequest = req.ClientRequest + " " + req.Message;
}
private MessageFromServerToClient MakeRequest([NotNull] RequestSocket socket, [NotNull] MessageFromClientToServer message)
{
byte[] messageBytes = LZ4MessagePackSerializer.Serialize(message);
byte[] answer;
Stopwatch sw = Stopwatch.StartNew();
TimeSpan ts = new TimeSpan(0, 1, 0);
lock (_socketLock) {
var success = socket.TrySendFrame(ts, messageBytes);
if (!success)
{
throw new DistSimException("could not send to server");
}
success = socket.TryReceiveFrameBytes(ts, out answer);
if (!success)
{
throw new DistSimException("could not receive from server");
}
}
var answermessage = LZ4MessagePackSerializer.Deserialize <MessageFromServerToClient>(answer);
sw.Stop();
var prettySizeSent = AutomationUtili.MakePrettySize(messageBytes.Length);
var prettysizeAnswer = AutomationUtili.MakePrettySize(answer.Length);
_logger.Info("Sent " + prettySizeSent + " and received an answer with a length of " + prettysizeAnswer + ", elapsed: " + sw.Elapsed,
_threadId);
return(answermessage);
}
private string MakeResultFileDirectory([NotNull] MessageFromClientToServer req)
{
if (_settings.ServerSettings.ResultArchiveDirectory == null)
{
throw new DistSimException("Result archive dir is null");
}
string resultFileArchiveDirectory = _settings.ServerSettings.ResultArchiveDirectory;
bool allok = true;
if (!string.IsNullOrWhiteSpace(req.Scenario))
{
resultFileArchiveDirectory = Path.Combine(resultFileArchiveDirectory, AutomationUtili.CleanFileName(req.Scenario));
}
else
{
allok = false;
}
if (!string.IsNullOrWhiteSpace(req.Year))
{
resultFileArchiveDirectory = Path.Combine(resultFileArchiveDirectory, AutomationUtili.CleanFileName(req.Year));
}
else
{
allok = false;
}
if (!string.IsNullOrWhiteSpace(req.Trafokreis))
{
resultFileArchiveDirectory = Path.Combine(resultFileArchiveDirectory, AutomationUtili.CleanFileName(req.Trafokreis));
}
else
{
allok = false;
}
if (!string.IsNullOrWhiteSpace(req.HouseName))
{
resultFileArchiveDirectory = Path.Combine(resultFileArchiveDirectory, AutomationUtili.CleanFileName(req.HouseName));
}
else
{
allok = false;
}
if (!allok)
{
var dt = DateTime.Now;
string datetimestr = dt.Year + "." + dt.Month + "." + dt.Day + "-" + dt.Hour + "." + dt.Minute + "." + dt.Second;
resultFileArchiveDirectory = Path.Combine(resultFileArchiveDirectory, "Broken", datetimestr);
Logger.Error("scenario information was broken, using the following directory instead: " + resultFileArchiveDirectory, _threadId);
}
Logger.Info("Saving results to: " + resultFileArchiveDirectory, _threadId);
if (resultFileArchiveDirectory == _settings.ServerSettings.ResultArchiveDirectory)
{
throw new DistSimException("Somehow the resultdirectory was the main archive directory. this is wrong.");
}
Logger.Info("Make result archive directory " + resultFileArchiveDirectory, _threadId);
return(resultFileArchiveDirectory);
}
private MessageFromServerToClient HandleTaskFinishReport([NotNull] MessageFromClientToServer req)
{
try {
_logger.Info("got a finish report from " + req.ClientName + " for " + req.HouseName, _threadId);
ServerExecutionTask set = ActiveTasks.FirstOrDefault(x => x.Guid == req.TaskGuid);
if (set == null)
{
return(new MessageFromServerToClient(ServerResponseEnum.JobFinishAck, req.TaskGuid));
//if it is an old task guid from previous run, just ignore the finish report
//throw new DistSimException("No task found for guid " + req.TaskGuid);
}
set.ExecutionEnd = DateTime.Now;
SaveExecuteHelper.Get().SaveExecuteWithWait(() => ActiveTasks.Remove(set));
SaveExecuteHelper.Get().SaveExecuteWithWait(() => {
FinishedTasks.Add(set);
while (FinishedTasks.Count > 20)
{
FinishedTasks.RemoveAt(0);
}
});
set.FinishStatusMessage = req.Message;
var resultFileArchiveDirectory = MakeResultFileDirectory(req);
DirectoryInfo di = new DirectoryInfo(resultFileArchiveDirectory);
if (di.Exists)
{
_logger.Info("deleting previous results from " + di.FullName, _threadId);
SaveDelete(di);
Thread.Sleep(250);
}
di.Create();
_logger.Info("created " + di.FullName, _threadId);
bool isFailure = false;
if (req.ResultFiles != null)
{
foreach (var jsonfile in req.ResultFiles)
{
string directory = Path.Combine(resultFileArchiveDirectory, jsonfile.RelativeDirectory);
DirectoryInfo subdir = new DirectoryInfo(directory);
if (!subdir.Exists)
{
subdir.Create();
}
string dstPath = Path.Combine(directory, jsonfile.FileName);
_logger.Info("writing " + dstPath + "," + "\nresult archive dir: " + resultFileArchiveDirectory + "\n relative dir: " +
jsonfile.RelativeDirectory,
_threadId);
jsonfile.WriteBytesFromJson(dstPath, Logger);
if (jsonfile.FileName.ToLower(CultureInfo.InvariantCulture) == "calculationexceptions.txt")
{
string fileContent = File.ReadAllText(dstPath);
_errorLogger.Error(set.OriginalJsonFilePath + " - error during calc " + fileContent, _threadId);
_logger.Error(set.OriginalJsonFilePath + " - error during calc " + fileContent, _threadId);
isFailure = true;
}
}
}
else
{
_logger.Error("No result files were delivered", _threadId);
}
ArchiveJsonFile(set, isFailure);
var answer = new MessageFromServerToClient(ServerResponseEnum.JobFinishAck, req.TaskGuid);
return(answer);
}
catch (Exception ex) {
_logger.Exception(ex, "Error while handling a finish report " + ex.Message);
throw;
}
}
