public void sendSimulationTask(SimulationInfo simulation)
{
if (this.session == null)
{
postMessage("Cannot send task; no session is active at the moment. ");
return;
}
taskRequests--;
TaskPackage taskPackage = new TaskPackage
{
taskID = nextTransmissionID++,
sessionID = this.session.sessionID,
simulationTask = simulation
};
try
{
networkStream.WriteByte((byte)TrasmissionFlags.Task);
formatter.Serialize(networkStream, taskPackage);
postMessage("Task sent to " + hostname + " on port " + port + " (session id: " + this.session.sessionID + ")");
sentSimulations.Add(taskPackage.taskID, simulation);
}
catch (Exception e)
{
postMessage(e.Message);
}
}
public override bool ConfirmStart()
{
if (string.IsNullOrEmpty(Filename))
{
if (string.IsNullOrEmpty(Name))
{
Console.WriteLine($"RunPackage requires either a name or a filename to execute");
return(false);
}
else
{
//activate & load the package
Console.WriteLine($"Activating Package {Name}");
package = PackageLibrary.GetPackage(Name);
if (package == null)
{
Console.WriteLine($"Package [{Name}] not found.\n\nSC> GetPackages\n");
// run GetPackages for the user
ConsoleProgram.StartTask("GetPackages");
Console.WriteLine($"\n\n");
return(false);
}
}
}
else
{
package = new TaskPackageFile(Filename);
}
return(base.ConfirmStart());
}
/// <summary>
/// Packing new task.
/// </summary>
/// <returns>TaskPackage</returns>
public ITaskPackage GetData()
{
EnterBlackBoxParam param = new EnterBlackBoxParam(LimitMin(varLimitations.x1), LimitMax(varLimitations.x1),
LimitMin(varLimitations.x2), LimitMax(varLimitations.x2), comprimate_min(), comprimate_max());
foreach (BlackBoxParam bbp in varLimitations.blackBoxes)
{
BlackBox bb = new BlackBox(bbp.info, bbp.pIn, bbp.pOut, bbp.qOut, bbp.tIn, bbp.dIn, "0"); //ВНЕМАТОЧНО!!!!!
bbParams.Add(bb);
}
TaskPackage task = new TaskPackage(bbParams, param, fileName);
return(task);
}
private void doWork()
{
try
{
while (true)
{
try
{
if (isPendingClose)
{
return;
}
TaskPackage taskPackage = null;
lock (taskSource)
{
if (taskSource.Count > 0)
{
taskPackage = taskSource.Dequeue();
}
}
if (taskPackage == null)
{
waitHandleBetweenTasks.WaitOne();
}
else
{
Console.WriteLine("Simulating " + taskPackage.simulationTask.predictorInfo.predictorTypeFullName + " on " + taskPackage.simulationTask.benchmarkInfo.benchmarkName);
BenchmarkStatisticsResult benchmarkStatisticsResult = taskPackage.simulationTask.simulate(ParentConnectionThread.SimulationSession.sessionOptions, Program.applicationOptions);
ParentConnectionThread.sendResult(taskPackage.taskID, benchmarkStatisticsResult);
ParentConnectionThread.sendTaskRequest();
}
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
}
}
catch (ThreadAbortException)
{
Console.WriteLine("The thread abortion process occured at a time when it could not be properly handled.");
}
}
public void handleConnection()
{
tcpClient = tcpListener.AcceptTcpClient();
networkStream = tcpClient.GetStream();
// initialization
header = networkStream.ReadByte();
if (header != (byte)TrasmissionFlags.ClientName)
{
Console.WriteLine("Client does not respect protocol.");
networkStream.Close();
tcpClient.Close();
return;
}
try
{
clientName = (string)formatter.Deserialize(networkStream);
Console.WriteLine("Connected to " + clientName + " on port " + port);
}
catch
{
Console.WriteLine("Client does not respect protocol.");
networkStream.Close();
tcpClient.Close();
return;
}
// main message loop
try
{
while (!requestClose)
{
header = networkStream.ReadByte();
if (header == -1)
{
break;
}
switch (header)
{
case (byte)TrasmissionFlags.NewSession:
this.simulationSession = (SimulationSession)formatter.Deserialize(networkStream);
Console.WriteLine("Starting new session with " + clientName + " (session id: " + this.simulationSession.sessionID + ")");
for (int i = 0; i < numberOfWorkerThreads; i++)
{
workerThreads[i].abortCurrentTask();
sendTaskRequest();
}
lock (taskBuffer) // cleanse taskBuffer of older parasite tasks
{
int taskBufferCount = taskBuffer.Count;
for (int i = 0; i < taskBufferCount; i++)
{
TaskPackage t = taskBuffer.Dequeue();
if (t.sessionID == this.simulationSession.sessionID)
{
taskBuffer.Enqueue(t);
}
}
}
break;
case (byte)TrasmissionFlags.Task:
TaskPackage taskPackage = (TaskPackage)formatter.Deserialize(networkStream);
if (this.simulationSession != null && taskPackage.sessionID == this.simulationSession.sessionID)
{
lock (taskBuffer)
{
taskBuffer.Enqueue(taskPackage);
}
for (int i = 0; i < numberOfWorkerThreads; i++)
{
workerThreads[i].awake();
}
Console.WriteLine("TaskPackage received from " + clientName);
}
else
{
Console.WriteLine("TaskPackage received from " + clientName + ", but belonging to a closed session.");
}
break;
case (byte)TrasmissionFlags.AbortSession:
uint sessionIdAborted = (uint)formatter.Deserialize(networkStream);
if (this.simulationSession != null && sessionIdAborted == this.simulationSession.sessionID)
{
for (int i = 0; i < numberOfWorkerThreads; i++)
{
if (workerThreads[i] != null)
{
workerThreads[i].abortCurrentTask();
}
}
Console.WriteLine("Session " + sessionIdAborted + " aborted.");
}
else
{
Console.WriteLine("Session abort message received (" + sessionIdAborted + ") but not for the current session. ");
}
break;
default:
break;
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.WriteLine("Connection to " + clientName + " terminated");
networkStream.Close();
tcpClient.Close();
}
private async Task <DownloadFile> DownloadFile()
{
if (string.IsNullOrEmpty(chosenFileName))
{
MessageBox.Show("Please choose a file");
return(null);
}
List <string> IpAdressList = await GetListOfIPAdresses(chosenFileName);
int peers = 0;
double size = 0;
foreach (FilesInfo fileInfo in myFilesList)
{
if (fileInfo.FileName.Equals(chosenFileName))
{
peers = fileInfo.Amount_Of_Peers;
size = fileInfo.Size;
}
}
DownloadFile download = new DownloadFile(chosenFileName, size);
string port_asString = ConfigurationManager.ConnectionStrings[USER_PORT].ToString();
Int32 port = Convert.ToInt32(port_asString);
var list = new List <TaskPackage>();
for (int i = 0; i < peers; i++)
{
TaskPackage taskPackage = new TaskPackage(i, peers, port, size, chosenFileName, IpAdressList[i]);
list.Add(taskPackage);
taskPackage.Task.Start();
}
int file_size = Convert.ToInt32(size) + 1;
FileStream fileStream = null;
try
{
for (int i = 0; i < list.Count; i++)
{
Task.WaitAny(list[i].Task);
}
fileStream = File.Open(downloadPath + "\\" + chosenFileName, FileMode.Create);
for (int i = 0; i < list.Count; i++)
{
fileStream.Write(list[i].Bytes, 0, list[i].Bytes.Length);
}
download.SetEndTime();
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
finally
{
fileStream.Close();
}
try
{
fileStream = File.Open(uploadPath + "\\" + chosenFileName, FileMode.Create);
for (int i = 0; i < list.Count; i++)
{
fileStream.Write(list[i].Bytes, 0, list[i].Bytes.Length);
}
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
finally
{
fileStream.Close();
}
UploadFilesToServer();
return(download);
}
