public ActiveImagingTaskController()
{
_activeImagingTaskService = new ServiceActiveImagingTask();
_auditLogService = new ServiceAuditLog();
_userId = Convert.ToInt32(((ClaimsIdentity)User.Identity).Claims.Where(c => c.Type == "user_id")
.Select(c => c.Value).SingleOrDefault());
}
private bool CreateComputerTasks()
{
var error = false;
var activeTaskIds = new List <int>();
var activeImagingTaskServices = new ServiceActiveImagingTask();
foreach (var computer in _computers)
{
if (_computerServices.IsComputerActive(computer.Id))
{
return(false);
}
var activeTask = new EntityActiveImagingTask
{
Type = "multicast",
ComputerId = computer.Id,
Direction = "deploy",
MulticastId = _multicastSession.Id,
UserId = _userId,
ImageProfileId = _imageProfile.Id
};
if (activeImagingTaskServices.AddActiveImagingTask(activeTask))
{
activeTaskIds.Add(activeTask.Id);
}
else
{
error = true;
break;
}
}
if (error)
{
foreach (var taskId in activeTaskIds)
{
activeImagingTaskServices.DeleteActiveImagingTask(taskId);
}
return(false);
}
return(true);
}
public string Upload(int taskId, string fileName, int profileId, int userId, string hdNumber)
{
//no need to find and call com server, client should already be directly communicating with the correct imaging server
var guid = ConfigurationManager.AppSettings["ComServerUniqueId"];
_thisComServer = new ServiceClientComServer().GetServerByGuid(guid);
if (_thisComServer == null)
{
log.Error($"Com Server With Guid {guid} Not Found");
return("0");
}
var appPath = Path.Combine(HttpContext.Current.Server.MapPath("~"), "private", "apps");
var task = new ServiceActiveImagingTask().GetTask(taskId);
if (task == null)
{
return("0");
}
var imageProfile = new ServiceImageProfile().ReadProfile(profileId);
var uploadPort = new ServicePort().GetNextPort(task.ComServerId);
var path = _thisComServer.LocalStoragePath;
try
{
var dir = Path.Combine(path, "images", imageProfile.Image.Name, $"hd{ hdNumber}");
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
}
catch (Exception ex)
{
log.Error("Could Not Create Directory");
log.Error(ex.Message);
return("0");
}
path = Path.Combine(path, "images", imageProfile.Image.Name, $"hd{hdNumber}", fileName);
string arguments = " /c \"";
var receiverPath = Path.Combine(appPath, "udp-receiver.exe");
arguments += $"{receiverPath}\" --portbase {uploadPort}";
arguments += $" --interface {_thisComServer.ImagingIp} --file {path}";
var pid = StartReceiver(arguments, imageProfile.Image.Name);
//use multicast session even though it's not a multicast, uploads still use udpcast
var activeMulticast = new EntityActiveMulticastSession();
if (pid != 0)
{
activeMulticast.ImageProfileId = imageProfile.Id;
activeMulticast.Name = imageProfile.Image.Name;
activeMulticast.Pid = pid;
activeMulticast.Port = uploadPort;
activeMulticast.ComServerId = _thisComServer.Id;
activeMulticast.UserId = userId;
activeMulticast.UploadTaskId = task.Id;
var result = new ServiceActiveMulticastSession().AddActiveMulticastSession(activeMulticast);
if (result)
{
return(uploadPort.ToString());
}
}
return("0");
}
public string Start()
{
if (_computer == null)
{
return("The Computer Does Not Exist");
}
if (_group != null)
{
//unicast started via group, use that groups assigned image
_imageProfile = new ServiceImageProfile().ReadProfile(_group.ImageProfileId);
if (_imageProfile == null)
{
return("The Image Profile Doesn't Exist");
}
}
else
{
_imageProfile = new ServiceComputer().GetEffectiveImage(_computer.Id);
}
if (_imageProfile == null)
{
return("No Image Has Been Selected");
}
if (_imageProfile.Image == null)
{
return("The Image Does Not Exist");
}
if (new ServiceComputer().IsComputerActive(_computer.Id))
{
return("This Computer Is Already Part Of An Active Task");
}
_activeTask = new EntityActiveImagingTask
{
ComputerId = _computer.Id,
Direction = _direction,
UserId = _userId,
ImageProfileId = _imageProfile.Id
};
_activeTask.Type = _direction;
var activeImagingTaskServices = new ServiceActiveImagingTask();
if (!activeImagingTaskServices.AddActiveImagingTask(_activeTask))
{
return("Could Not Create The Database Entry For This Task");
}
if (!new TaskBootMenu().RunAllServers(_computer, _imageProfile))
{
activeImagingTaskServices.DeleteActiveImagingTask(_activeTask.Id);
return("Could Not Create PXE Boot File");
}
_activeTask.Arguments = new CreateTaskArguments(_computer, _imageProfile, _direction).Execute();
if (!activeImagingTaskServices.UpdateActiveImagingTask(_activeTask))
{
activeImagingTaskServices.DeleteActiveImagingTask(_activeTask.Id);
return("Could Not Create Task Arguments");
}
new ServiceComputer().Wakeup(_computer.Id);
var auditLog = new EntityAuditLog();
switch (_direction)
{
case "deploy":
auditLog.AuditType = EnumAuditEntry.AuditType.Deploy;
break;
default:
auditLog.AuditType = EnumAuditEntry.AuditType.Upload;
break;
}
auditLog.ObjectId = _computer.Id;
var user = new ServiceUser().GetUser(_userId);
if (user != null)
{
auditLog.UserName = user.Name;
}
auditLog.ObjectName = _computer.Name;
auditLog.UserId = _userId;
auditLog.ObjectType = "Computer";
auditLog.ObjectJson = JsonConvert.SerializeObject(_activeTask);
new ServiceAuditLog().AddAuditLog(auditLog);
auditLog.ObjectId = _imageProfile.ImageId;
auditLog.ObjectName = _imageProfile.Image.Name;
auditLog.ObjectType = "Image";
new ServiceAuditLog().AddAuditLog(auditLog);
return("Successfully Started Task For " + _computer.Name);
}
