/// <summary>
/// Adds new task to db and tasks list.
/// </summary>
/// <param name="action">
/// The action.
/// </param>
/// <param name="taskType">
/// The task Type.
/// </param>
public long CreateTask(Func <Dictionary <string, string> > action, TaskType taskType)
{
CalculationTask databaseTask;
Task task;
using (var db = new LibiadaWebEntities())
{
databaseTask = new CalculationTask
{
Created = DateTime.Now,
Description = taskType.GetDisplayValue(),
Status = TaskState.InQueue,
UserId = AccountHelper.GetUserId(),
TaskType = taskType
};
db.CalculationTask.Add(databaseTask);
db.SaveChanges();
}
lock (tasks)
{
task = new Task(databaseTask.Id, action, databaseTask.UserId, taskType);
lock (task)
{
tasks.Add(task);
signalrHub.Send(TaskEvent.AddTask, task.TaskData);
}
}
ManageTasks();
return(task.TaskData.Id);
}
/// <summary>
/// Deletes the task by id.
/// </summary>
/// <param name="id">
/// The task id.
/// </param>
public void DeleteTask(long id)
{
lock (tasks)
{
Task task = tasks.Single(t => t.TaskData.Id == id);
if (task.TaskData.UserId == AccountHelper.GetUserId() || AccountHelper.IsAdmin())
{
lock (task)
{
if ((task.SystemTask != null) && (!task.SystemTask.IsCompleted))
{
CancellationTokenSource cancellationTokenSource = task.CancellationTokenSource;
cancellationTokenSource.Cancel();
cancellationTokenSource.Dispose();
}
tasks.Remove(task);
using (var db = new LibiadaWebEntities())
{
CalculationTask databaseTask = db.CalculationTask.Find(id);
db.CalculationTask.Remove(databaseTask);
db.SaveChanges();
}
signalrHub.Send(TaskEvent.DeleteTask, task.TaskData);
}
}
}
}
/// <summary>
/// Deletes the task by id.
/// </summary>
/// <param name="id">
/// The task id.
/// </param>
public void DeleteTask(long id)
{
lock (tasks)
{
Task task = tasks.Single(t => t.TaskData.Id == id);
if (task.TaskData.UserId == AccountHelper.GetUserId() || AccountHelper.IsAdmin())
{
lock (task)
{
if (task.Thread != null && task.Thread.IsAlive)
{
task.Thread.Abort();
}
tasks.Remove(task);
using (var db = new LibiadaWebEntities())
{
CalculationTask databaseTask = db.CalculationTask.Find(id);
db.CalculationTask.Remove(databaseTask);
db.SaveChanges();
}
signalrHub.Send(TaskEvent.DeleteTask, task.TaskData);
}
}
}
}
public void InitProcess(CalculationTask calculationTask, INetCreator netcreater)
{
NetMap = netcreater.CreateNet();
_calculationTask = calculationTask;
SelectAB();
_percalationResult = new List <int>(_calculationTask.CountOfIteration);
}
public void InitProcess(CalculationTask calculationTask, INetCreator netcreater)
{
_netMap = netcreater.CreateNet();
UseOnlyActiveNodes();
_calculationTask = calculationTask;
SelectAb();
_percalationResult = new List <int>(_calculationTask.CountOfIteration);
_random = new Random();
}
/// <summary>
/// Initializes a new instance of the <see cref="Task"/> class.
/// </summary>
/// <param name="task">
/// The task.
/// </param>
public Task(CalculationTask task)
{
TaskData = new TaskData(task);
//Result = new Dictionary<string, string> { { "data", task.Result } };
//if (!string.IsNullOrEmpty(task.AdditionalResultData))
//{
// // TODO: rewrite to use more abstract class or leave json for further parsing
// Result.Add("additionalData", JsonConvert.DeserializeObject<List<(int, int, double)>[,]>(task.AdditionalResultData));
//}
}
public void Serialize()
{
CalculationTask calc = new CalculationTask(NetType.MultyLink.ToString(), 1000000, 10, 10, 0, 0);
byte[] len = CalculationTask.GetbytesFromCalculationTask(calc);
CalculationTask calc2 = CalculationTask.GetCalculationTaskFrombytes(len);
Assert.IsTrue(calc.NetType == calc2.NetType);
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskData"/> class.
/// </summary>
/// <param name="task">
/// The task.
/// </param>
public TaskData(CalculationTask task)
{
Id = task.Id;
TaskType = task.TaskType;
UserId = task.UserId;
UserName = AccountHelper.GetUserNameById(task.UserId);
Created = task.Created;
Started = task.Started;
Completed = task.Completed;
ExecutionTime = Completed - Started;
TaskState = task.Status;
}
public static CalculationTaskDto FromEntityToDto(CalculationTask entity, List <EnhancementSet> enhancementSets)
{
return(new CalculationTaskDto
{
Id = entity.Id,
EndDate = entity.EndDate,
Status = (int)entity.Status,
StartDate = entity.StartDate,
Threshold = entity.Threshold,
FoundSets = entity.FoundSets,
EnhancementSets = enhancementSets?.Select(e => EnhancementSetDtoConvertor.FromEntityToDto(e, null)).ToList()
});
}
public async void StartTask(CalculationTask task, List <Enhancement> enhancements)
{
this.logger.LogDebug($"Task {task.Id} is starting.");
task.Status = CalculationTaskStatus.Started;
task.StartDate = DateTime.Now;
task.FoundSets = 0;
await this.context.CalculationTaskRepository.UpdateAsync(task.Id, task, true);
foreach (var combination in this.GetCombinations(enhancements, task.Threshold, string.Empty))
{
var newSetFound = combination.Split(' ').Select(result => enhancements.First(e => e.Id.Equals(Convert.ToInt32(result)))).ToList();
var setName = string.Join(';', newSetFound.OrderBy(e => e.Name).Select(e => e.Name).ToArray());
var setInternalName = string.Join(';', newSetFound.OrderBy(e => e.Id).Select(e => e.Id).ToArray());
if (this.context.EnhancementSetRepository.All().FirstOrDefault(es => es.SetInternalName.Equals(setInternalName)) != null)
{
continue;
}
var newSet = await this.context.EnhancementSetRepository.AddAsync(new EnhancementSet { SetName = setName, SetInternalName = setInternalName, Threshold = task.Threshold, IsInvalid = false, CalculationTaskId = task.Id }, true);
task.FoundSets++;
var enhancementSetEnhancements = new List <EnhancementSetEnhancement>();
enhancementSetEnhancements.AddRange(newSetFound.Select(e => new EnhancementSetEnhancement {
EnhancementSetId = newSet.Id, EnhancementId = e.Id
}));
task.LastUpdate = DateTime.Now;
var updatedTask = await this.context.CalculationTaskRepository.UpdateAsync(task.Id, task, true);
await this.context.EnhancementSetEnhancementRepository.AddAllAsync(enhancementSetEnhancements);
var reloadedTask = this.context.CalculationTaskRepository.Reload(updatedTask);
if (reloadedTask.Status == CalculationTaskStatus.Stopped)
{
break;
}
}
if (task.FoundSets == 0)
{
await this.context.EnhancementSetRepository.AddAsync(new EnhancementSet { SetName = "Invalid", Threshold = task.Threshold, IsInvalid = true, CalculationTaskId = task.Id }, true);
}
task.Status = CalculationTaskStatus.Ended;
task.EndDate = DateTime.Now;
this.logger.LogDebug($"Task {task.Id} is completed.");
await this.context.CalculationTaskRepository.UpdateAsync(task.Id, task, true);
}
private void PerformTask(CalculationTask task)
{
switch (task.Operation)
{
case Operation.Add:
Add(task.Matrices);
break;
case Operation.Subtract:
Subtract(task.Matrices);
break;
case Operation.Multiply:
Multiply(task.Matrices);
break;
case Operation.Transpose:
Transpose(task.Matrices);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Starts a new thread with the given task.
/// </summary>
/// <param name="task">
/// The task.
/// </param>
private void ExecuteTaskAction(Task task)
{
try
{
Func <Dictionary <string, string> > actionToCall;
lock (task)
{
actionToCall = task.Action;
task.TaskData.Started = DateTime.Now;
using (var db = new LibiadaWebEntities())
{
CalculationTask databaseTask = db.CalculationTask.Single(t => t.Id == task.TaskData.Id);
databaseTask.Started = DateTime.Now;
databaseTask.Status = TaskState.InProgress;
db.Entry(databaseTask).State = EntityState.Modified;
db.SaveChanges();
}
signalrHub.Send(TaskEvent.ChangeStatus, task.TaskData);
}
// executing action
Dictionary <string, string> result = actionToCall();
lock (task)
{
task.TaskData.Completed = DateTime.Now;
task.TaskData.ExecutionTime = task.TaskData.Completed - task.TaskData.Started;
TaskResult[] results = result.Select(r => new TaskResult {
Key = r.Key, Value = r.Value, TaskId = task.TaskData.Id
}).ToArray();
task.TaskData.TaskState = TaskState.Completed;
using (var db = new LibiadaWebEntities())
{
db.TaskResult.AddRange(results);
CalculationTask databaseTask = db.CalculationTask.Single(t => (t.Id == task.TaskData.Id));
databaseTask.Completed = DateTime.Now;
databaseTask.Status = TaskState.Completed;
db.Entry(databaseTask).State = EntityState.Modified;
db.SaveChanges();
}
signalrHub.Send(TaskEvent.ChangeStatus, task.TaskData);
}
}
catch (ThreadAbortException)
{
// TODO: implement an exception handling/logging
}
catch (Exception e)
{
string errorMessage = e.Message;
string stackTrace = e.StackTrace;
while (e.InnerException != null)
{
e = e.InnerException;
errorMessage += $"{Environment.NewLine} {e.Message}";
}
lock (task)
{
var taskData = task.TaskData;
taskData.Completed = DateTime.Now;
taskData.ExecutionTime = taskData.Completed - taskData.Started;
taskData.TaskState = TaskState.Error;
var error = new { Message = errorMessage, StackTrace = stackTrace };
TaskResult taskResult = new TaskResult
{
Key = "Error", Value = JsonConvert.SerializeObject(error), TaskId = taskData.Id
};
using (var db = new LibiadaWebEntities())
{
db.TaskResult.Add(taskResult);
CalculationTask databaseTask = db.CalculationTask.Single(t => (t.Id == taskData.Id));
databaseTask.Completed = DateTime.Now;
databaseTask.Status = TaskState.Error;
db.Entry(databaseTask).State = EntityState.Modified;
db.SaveChanges();
}
signalrHub.Send(TaskEvent.ChangeStatus, taskData);
}
}
finally
{
ManageTasks();
}
}
private void SaveExp_Click(object sender, RoutedEventArgs e)
{
CalculationTask[] temp = new CalculationTask[(int)ExpCount.Value];
string nettype = "";
if (MultyLink.IsChecked != null && (bool)MultyLink.IsChecked)
{
nettype = MultyLink.Name;
}
if (Keily.IsChecked != null && (bool)Keily.IsChecked)
{
nettype = Keily.Name;
}
if (Quadro.IsChecked != null && (bool)Quadro.IsChecked)
{
nettype = Quadro.Name;
}
if (KeilyRegular.IsChecked != null && (bool)KeilyRegular.IsChecked)
{
nettype = KeilyRegular.Name;
}
if (TriangleIrregular.IsChecked != null && (bool)TriangleIrregular.IsChecked)
{
nettype = TriangleIrregular.Name;
}
if (TriangleRegular.IsChecked != null && (bool)TriangleRegular.IsChecked)
{
nettype = TriangleRegular.Name;
}
if (Hexagon.IsChecked != null && (bool)Hexagon.IsChecked)
{
nettype = Hexagon.Name;
}
if (Net3122.IsChecked != null && (bool)Net3122.IsChecked)
{
nettype = Net3122.Name;
}
if (nettype == "")
{
return;
}
//for (int i = 0; i < taskcount; i++)
//{
// temp[i] = new CalculationTask
// {
// PofInfective = _pofInfective,
// NodeCount = _nodecount,
// NetType = nettype,
// IsAdresDiff = _isAdresDiff,
// IsAppend = _isAppend,
// MaxVirus = _maxVirus
// };
// if (!_isAdresDiff)
// {
// temp[i].VirusStrategy = VirusSendStrategy.None.ToString();
// }
// else
// {
// //temp[i].VirusStrategy
// }
// if (nettype != NetType.Keily.ToString() || nettype != NetType.MultyLink.ToString())
// {
// temp[i].MinLink = 0;
// temp[i].MaxLink = 0;
// temp[i].AddToMaxLinkCount = 0;
// }
// else
// {
// temp[i].MinLink = _minLinks;
// temp[i].AddToMaxLinkCount = _addLinks;
// temp[i].MaxLink = _addLinks + _minLinks;
// }
//}
}
/// <summary>
/// Starts a new thread with the given task.
/// </summary>
/// <param name="task">
/// The task.
/// </param>
private void ExecuteTaskAction(Task task)
{
try
{
Func <Dictionary <string, object> > actionToCall;
lock (task)
{
actionToCall = task.Action;
task.TaskData.Started = DateTime.Now;
using (var db = new LibiadaWebEntities())
{
CalculationTask databaseTask = db.CalculationTask.Single(t => t.Id == task.TaskData.Id);
databaseTask.Started = DateTime.Now;
databaseTask.Status = TaskState.InProgress;
db.Entry(databaseTask).State = EntityState.Modified;
db.SaveChanges();
}
signalrHub.Send(TaskEvent.ChangeStatus, task.TaskData);
}
// executing action
Dictionary <string, object> result = actionToCall();
lock (task)
{
task.TaskData.Completed = DateTime.Now;
task.TaskData.ExecutionTime = task.TaskData.Completed - task.TaskData.Started;
task.Result = result;
task.TaskData.TaskState = TaskState.Completed;
using (var db = new LibiadaWebEntities())
{
CalculationTask databaseTask = db.CalculationTask.Single(t => (t.Id == task.TaskData.Id));
databaseTask.Completed = DateTime.Now;
databaseTask.Status = TaskState.Completed;
if (result.ContainsKey("data"))
{
databaseTask.Result = result["data"].ToString();
}
if (result.ContainsKey("additionalData"))
{
databaseTask.AdditionalResultData = JsonConvert.SerializeObject(result["additionalData"]);
}
db.Entry(databaseTask).State = EntityState.Modified;
db.SaveChanges();
}
signalrHub.Send(TaskEvent.ChangeStatus, task.TaskData);
}
}
catch (Exception e)
{
string errorMessage = e.Message;
string stackTrace = e.StackTrace;
while (e.InnerException != null)
{
e = e.InnerException;
errorMessage += $"{Environment.NewLine} {e.Message}";
}
lock (task)
{
task.TaskData.Completed = DateTime.Now;
task.TaskData.ExecutionTime = task.TaskData.Completed - task.TaskData.Started;
task.TaskData.TaskState = TaskState.Error;
task.Result = new Dictionary <string, object>
{
{ "Error", true },
{ "ErrorMessage", errorMessage },
{ "StackTrace", stackTrace }
};
using (var db = new LibiadaWebEntities())
{
CalculationTask databaseTask = db.CalculationTask.Single(t => (t.Id == task.TaskData.Id));
databaseTask.Completed = DateTime.Now;
databaseTask.Status = TaskState.Error;
databaseTask.Result = JsonConvert.SerializeObject(task.Result);
db.Entry(databaseTask).State = EntityState.Modified;
db.SaveChanges();
}
signalrHub.Send(TaskEvent.ChangeStatus, task.TaskData);
}
}
ManageTasks();
}
static void Calc(string[] userinput, double averageLinkCount)
{
string netType = Properties.Settings.Default.NetType;
INetCreator Netcreator = null;
IProcessor processor;
var path = Directory.GetCurrentDirectory() + @"\Results\";
Directory.CreateDirectory(path);
CalculationTask calculationTask;
#region Select CalculationTask
ComaSepareteFileWriter writer = null;
switch (userinput[0])
{
case "4":
{
calculationTask = new CalculationTask(0, Nodecount, netType, Minlink, Addtomaxlinkcount, MaxVirus, PofInfective, Granica, Segmentcont, Adressdiffstrategy, Virussendstrategy, Isappend, Isadresdiff,
Iterationcount, path, percentbackupchannel);
processor = new TrueProcessor();
break;
}
case "TrueReferenceProcessor":
{
calculationTask = new CalculationTask(0, Nodecount, netType, Minlink, (int)averageLinkCount, MaxVirus, PofInfective, Granica, Segmentcont, Adressdiffstrategy, Virussendstrategy, Isappend, Isadresdiff,
Iterationcount, path, percentbackupchannel);
processor = new TrueReferenceProcessor();
break;
}
case "ReferenceProcessor":
{
calculationTask = CalculationTaskCreator.CreateForReferencesCalculator(path, Iterationcount, netType);
var weight = FileNetLoad.ReadWeight(userinput[3], Properties.Settings.Default.DefaultConnectionWeight);
var st = userinput[3];
for (int i = 4; i < userinput.Length; i++)
{
weight = FileNetLoad.MultiplyWeight(weight, FileNetLoad.ReadWeight(userinput[i], Properties.Settings.Default.DefaultConnectionWeight));
st += "-" + userinput[i];
}
processor = new ReferencesProcessor(weight);
writer = new ComaSepareteFileWriter(Path.Combine(path, st + "_" + Properties.Settings.Default.DefaultConnectionWeight));
break;
}
default:
{
Console.WriteLine(@"Input is not correct");
return;
}
}
#endregion
#region Select NetBuilder
switch (userinput[1])
{
case "NetBuilder":
{
Netcreator = new NetBuilder(calculationTask);
break;
}
case "HoleNetCreator":
{
Netcreator = new HoleNetCreator(new NetBuilder(calculationTask), averageLinkCount);
break;
}
case "FileNetLoad":
{
Netcreator = new FileNetLoad(userinput[2]);
break;
}
default:
{
Console.WriteLine(@"Input is not correct");
return;
}
}
#endregion
if (writer == null)
{
writer =
new ComaSepareteFileWriter(Path.Combine(path, calculationTask.NetType + "_" + averageLinkCount.ToString("0.00")));
}
var d = new SimpleKernel(processor, calculationTask, Netcreator, writer, Experementcount);
}
public void TestInitProcess()
{
var t = new CalculationTask("Cube", 27);
_target.InitProcess(t, new NetBuilder(t));
}
