public void SendStatusThread()
{
while (!statusThreadCancellationTokenSource.IsCancellationRequested)
{
var socket = communicationModule.SetupClient();
communicationModule.Connect(socket);
var st = new StatusThread()
{
HowLong = (ulong)(DateTime.Now - startTime).TotalMilliseconds,
TaskId = 1,
State = StatusThreadState.Idle,
ProblemType = "DVRP",
ProblemInstanceId = 1,
TaskIdSpecified = true
};
var statusMessage = new StatusMessage(this.NodeId, new StatusThread[] { st });
var statusMessageString = SerializeMessage(statusMessage);
communicationModule.SendData(statusMessageString, socket);
var receivedMessage = communicationModule.ReceiveData(socket);
communicationModule.CloseSocket(socket);
if (!String.IsNullOrEmpty(receivedMessage))
{
ProcessMessage(receivedMessage);
}
Thread.Sleep((int)(threadSleepTimeout * 0.8));
}
}
/// <summary>
/// Returns a status message based on this object
/// </summary>
/// <returns></returns>
public StatusMessage ToStatusMessage()
{
StatusThread[] statusThreads = new StatusThread[ParallelThreads];
for (int i = 0; i < ParallelThreads; i++)
{
statusThreads[i] = TaskThreads[i].StatusThread;
}
return(new StatusMessage(Id, statusThreads));
}
public StatusInformationBar(TextBox tb)
{
StatusBox = tb;
IsRunning = true;
HasChanged = true;
Indicators = new Dictionary <string, string>();
Task = new StatusThread(this);
Task.Start();
}
/******************************************************************/
/************************** CONSTRUCTORS **************************/
/******************************************************************/
public TaskThread(int id, string solvableProblem, MessageProcessor messageProcessor, int nodeID)
{
NodeID = nodeID;
ID = id;
// UCCTaskSolver.TaskSolver taskSolver = UCCTaskSolver.TaskSolverCreator();
//TaskSolver = taskSolver;
StatusThread = new StatusThread(StatusThreadState.Idle);
MessageProcessor = messageProcessor;
SolvableProblem = solvableProblem;
}
public static StatusMessage CreateStatusMessage()
{
ulong id = 12;
StatusThread statusThread1 = new StatusThread(StatusThreadState.Idle);
StatusThread statusThread2 = new StatusThread(StatusThreadState.Idle);
ulong howLong = 1000;
ulong problemInstanceId = 2;
ulong taskId = 1;
string problemType = "TCP";
StatusThread statusThread3 = new StatusThread(StatusThreadState.Busy, howLong, problemInstanceId, taskId, problemType);
StatusThread[] statusThreads = { statusThread1, statusThread2, statusThread3 };
StatusMessage expectedMessage = new StatusMessage(id, statusThreads);
return(expectedMessage);
}
public void TestMethod1()
{
// START THREAD
var thread = new Thread(new ThreadStart(() => Task.WhenAll(taskPool)));
thread.Start();
// STATUS DELEGATE
StatusThread status = (k, m) =>
{
System.Diagnostics.Debug.WriteLine($"Thread {k}; status message={m}");
Console.WriteLine($"Thread {k}; status message={m}");
};
// PARAMS
string output_file = Path.Combine(Directory.GetCurrentDirectory(), "converted");
string[] formats = new[] { "CSV", "TXT" };
int count = 2; //count gen files
int lines = 500; //count gen lines
// WORK
for (int i = count; i >= 1; i--)
{
var fileName = CreateBinFile(Path.Combine(Directory.GetCurrentDirectory(), "binary", $"temp_{i}.bin"), lines * i).Result;
taskPool.Add(WorkMethod(fileName, output_file, formats, status));
Thread.Sleep(500);
}
//Thread.Sleep(50000);
//thread.Abort();
while (true)
{
;
}
}
public void Parse_XMLString_StatusMessage()
{
/*********** Actual message ***********/
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"xml_samples\Status.xml");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(path);
string xmlStr = xmlDoc.OuterXml;
string name = Message.GetMessageName(xmlStr);
StatusMessage actualMessage = null;
if (name == StatusMessage.ELEMENT_NAME)
{
actualMessage = StatusMessage.Construct(xmlStr);
}
/*********** Expected message ***********/
ulong id = 12;
StatusThread statusThread1 = new StatusThread(StatusThreadState.Idle);
StatusThread statusThread2 = new StatusThread(StatusThreadState.Idle);
ulong howLong = 1000;
ulong problemInstanceId = 2;
ulong taskId = 1;
string problemType = "TCP";
StatusThread statusThread3 = new StatusThread(StatusThreadState.Busy, howLong, problemInstanceId, taskId, problemType);
StatusThread[] statusThreads = { statusThread1, statusThread2, statusThread3 };
StatusMessage expectedMessage = new StatusMessage(id, statusThreads);
Assert.AreEqual(expectedMessage, actualMessage);
}
public void StatusMessageSerialization()
{
string testData = System.IO.File.ReadAllText(@"XMLTestData\StatusMessage.xml");
var serializer = new ComputationSerializer <StatusMessage>();
StatusThread st = new StatusThread()
{
State = StatusThreadState.Idle,
HowLong = 1,
ProblemInstanceId = 1,
TaskId = 5,
TaskIdSpecified = true,
ProblemType = "TSP"
};
var statusMessage = new StatusMessage()
{
Id = 1,
Threads = new StatusThread[] { st }
};
var result = serializer.Serialize(statusMessage);
Assert.AreEqual(result, testData);
}
private void TaskWork()
{
networkAdapter.StartConnection();
SendRegisterMessage();
RecieveRegisterResponse();
networkAdapter.CloseConnection();
statusThreads = new StatusThread[1];
statusThreads[0] = new StatusThread { State = StatusThreadState.Idle, HowLong = 0, TaskId = registerResponse.Id, ProblemType = "DVRP" };
networkAdapter.CurrentStatus = new Status { Id = registerResponse.Id, Threads = statusThreads };
int timeout = int.Parse(registerResponse.Timeout.Substring(6, 2));
networkAdapter.StartKeepAliveTask(timeout * 1000, SendPartialProblems, SendFinalSolution, ReceiveDivide, ReceiveSolutions);
}
private void initThread()
{
threads = new StatusThread[availableThreads];
for (int i = 0; i < availableThreads;++i)
{
threads[i] = new StatusThread
{
HowLong = 0,
State = StatusThreadState.Idle ,
};
}
}
/// <summary>
/// Загружет и конвертирует бинарные файлы в пользовательские форматы.
/// Результат сохраняется в папке.
/// </summary>
/// <param name="input_fileName">Бинарный файл</param>
/// <param name="output_Path">Папка в которую сохраняются сконвертированные файлы</param>
/// <param name="formats">Массив выходных форматов</param>
/// <param name="status">Обработчик сообщений</param>
/// <returns></returns>
private Task WorkMethod(string input_fileName, string output_Path, string[] formats, StatusThread status = null)
{
return(Task.Run(() =>
{
if (!Directory.Exists(output_Path))
{
Directory.CreateDirectory(output_Path);
}
var fInf = new FileInfo(input_fileName);
string outFileName = fInf.Name.Replace(fInf.Extension, string.Empty);
// READ BIN FILE
List <TradeRecord> records = new List <TradeRecord>();
if (File.Exists(input_fileName))
{
// CREATE ARRAY WRITE STREAMS
Dictionary <string, TEMPSt> help = new Dictionary <string, TEMPSt>();
foreach (var f in formats)
{
try
{
status?.Invoke(fInf.Name, $"Initialize {f}Converter...");
var inst = Activator.CreateInstance(Assembly.GetExecutingAssembly().FullName, $"{f}Converter");
var converter = inst.Unwrap() as Interfaces.ToFileConverter;
help.Add(f,
new TEMPSt(
new FileStream(Path.Combine(output_Path, $"{outFileName}.{f}"), FileMode.Create),
converter));
}
catch (Exception)
{
status?.Invoke(fInf.Name, $"Error! No exists class {f}Converter!");
}
}
// READING
using (var fs = new FileStream(input_fileName, FileMode.Open))
{
status?.Invoke(fInf.Name, "Start reading...");
byte[] buff = new byte[Marshal.SizeOf(typeof(TradeRecord))];
int cnt = 0;
while (fs.Read(buff, 0, buff.Length) > 0)
{
var record = Helpers.StructSerializer.DeserializeStruct <TradeRecord>(buff);
// CONVERT TO FORMATS
foreach (var f in formats)
{
if (!help.ContainsKey(f))
{
break;
}
help[f].converter.Convert(record);
help[f].converter.Save(help[f].stream);
help[f].stream.Flush(true);
}
double percent = ((double)fs.Position / (double)fs.Length) * 100;
status?.Invoke(fInf.Name, $"Read record={cnt++}; complete={percent:0.00}%");
}
}
// CLEAR
foreach (var h in help)
{
h.Value.stream.Close();
}
help.Clear();
status?.Invoke(fInf.Name, $"Complete!");
}
}));
}
