public async Task <IActionResult> GetStatus(int id)
{
var userLab = await DatabaseContext.UserLabs
.IncludeRelations()
.WhereIncludesUser(GetUser())
.FirstAsync(ul => ul.Id == id);
if (userLab == null)
{
return(NotFound());
}
userLab.LastUsed = DateTime.UtcNow;
await DatabaseContext.SaveChangesAsync();
var dic = new Dictionary <int, string>();
var api = ProxmoxManager.GetProxmoxApi(userLab);
foreach (var vm in userLab.UserLabVms)
{
var status = await api.GetVmStatus(vm.ProxmoxVmId);
dic.Add(vm.Id, status.Status);
}
return(Ok(dic));
}
public async Task <IActionResult> Status(int id)
{
var userLab = DatabaseContext.UserLabs
.Include(l => l.HypervisorNode)
.ThenInclude(n => n.Hypervisor)
.Include(l => l.UserLabVms)
.WhereIncludesUser(GetUser())
.FirstOrDefault(m => m.Id == id);
if (userLab == null)
{
return(NotFound());
}
var api = ProxmoxManager.GetProxmoxApi(userLab);
foreach (var vm in userLab.UserLabVms)
{
var status = await api.GetVmStatus(vm.ProxmoxVmId);
if (status.Lock == "clone")
{
return(Ok("Initializing"));
}
}
return(Ok("Initialized"));
}
public async Task <IActionResult> Scrub(int id)
{
var vm = await DatabaseContext.UserLabVms
.Include(l => l.HypervisorVmTemplate)
.ThenInclude(l => l.HypervisorNode)
.ThenInclude(l => l.Hypervisor)
.Include(l => l.UserLab)
.ThenInclude(l => l.BridgeInstances)
.WhereIncludesUser(GetUser())
.FirstAsync(v => v.Id == id);
if (vm.IsCoreRouter)
{
return(NotFound());
}
var api = ProxmoxManager.GetProxmoxApi(vm.HypervisorVmTemplate.HypervisorNode);
await api.DestroyVm(vm.ProxmoxVmId);
await api.CloneTemplate(api.HypervisorNode, vm.HypervisorVmTemplate.TemplateVmId, vm.ProxmoxVmId);
await _userLabInstantiation.LinkVmToBridges(vm.UserLab, vm, api, vm.HypervisorVmTemplate.HypervisorNode);
var status = await api.GetVmStatus(vm.ProxmoxVmId);
while (status.Lock == "clone")
{
status = await api.GetVmStatus(vm.ProxmoxVmId);
}
await api.StartVM(vm.ProxmoxVmId);
return(Ok());
}
public async Task Deconstruct(UserLab userLab, ProxmoxManager proxmoxManager)
{
var api = proxmoxManager.GetProxmoxApi(userLab);
var userLabVms = userLab.UserLabVms.ToList();
foreach (var userLabVm in userLabVms)
{
await api.DestroyVm(userLabVm.ProxmoxVmId);
_context.UserLabVms.Remove(userLabVm);
await _context.SaveChangesAsync();
}
var bridgeInstances = userLab.BridgeInstances.ToList();
foreach (var bridge in bridgeInstances)
{
await api.DestroyBridge(bridge.HypervisorInterfaceId);
_context.BridgeInstances.Remove(bridge);
await _context.SaveChangesAsync();
}
userLab.Status = EUserLabStatus.Completed;
await _context.SaveChangesAsync();
}
public async Task <IActionResult> GetTicket(int id)
{
var vm = await GetVm(id);
if (vm == null || vm.IsCoreRouter)
{
return(NotFound());
}
var url = vm.UserLab.HypervisorNode.Hypervisor.NoVncUrl
.Replace("{node}", vm.UserLab.HypervisorNode.Name)
.Replace("{vm}", vm.ProxmoxVmId.ToString());
var ticket = await ProxmoxManager.GetProxmoxApi(vm.UserLab).GetTicket(vm.ProxmoxVmId);
url += "?port=" + ticket.Port + "&vncticket=" + HttpUtility.UrlEncode(ticket.Ticket);
return(Ok(new
{
Ticket = ticket.Ticket,
Port = ticket.Port,
Url = url,
FastBaseUrl = AppSettings.NoVnc.FastBaseUrl,
ReliableBaseUrl = AppSettings.NoVnc.ReliableBaseUrl,
HealthCheckUrl = AppSettings.NoVnc.HealthCheckUrl,
UseHttpsForHealthCheckRequest = AppSettings.NoVnc.UseHttpsForHealthCheckRequest
}));
}
public BaseController(BaseControllerDependencies dependencies)
{
this.DatabaseContext = dependencies.DatabaseContext;
this.Mapper = dependencies.Mapper;
this.ProxmoxManager = dependencies.ProxmoxManager;
this.EmailFactory = dependencies.EmailFactory;
this.WebAppUrl = dependencies.AppSettings.WebAppUrl;
this.AppSettings = dependencies.AppSettings;
}
public async Task <IActionResult> StartUp(int id)
{
var vm = await GetVm(id);
if (vm == null || vm.IsCoreRouter)
{
return(NotFound());
}
await ProxmoxManager.GetProxmoxApi(vm.UserLab).StartVM(vm.ProxmoxVmId);
return(Ok());
}
public BaseControllerDependencies(
DefaultContext defaultContext,
IMapper mapper,
ProxmoxManager proxmoxManager,
IFluentEmailFactory emailFactory,
AppSettings appSettings)
{
this.DatabaseContext = defaultContext;
this.Mapper = mapper;
this.ProxmoxManager = proxmoxManager;
this.EmailFactory = emailFactory;
this.AppSettings = appSettings;
}
public async Task <IActionResult> Shutdown(int id)
{
var vm = await GetVm(id);
if (vm == null)
{
return(NotFound());
}
var api = ProxmoxManager.GetProxmoxApi(vm.UserLab);
await api.ShutdownVm(vm.ProxmoxVmId);
return(Ok());
}
public async Task <IActionResult> TestProxmoxConnection()
{
var hypervisors = await DatabaseContext.Hypervisors
.Include(h => h.HypervisorNodes)
.ToListAsync();
foreach (var hypervisor in hypervisors)
{
var api = ProxmoxManager.GetProxmoxApi(hypervisor.HypervisorNodes.First());
foreach (var node in hypervisor.HypervisorNodes)
{
await api.GetNodeStatus(node);
}
}
return(Ok("All Hypervisors are up and responding"));
}
public async Task Instantiate(UserLab userLab, ProxmoxManager ProxmoxManager)
{
var node = await ProxmoxManager.GetLeastLoadedHyperVisorNode(userLab.Lab);
var api = ProxmoxManager.GetProxmoxApi(GetFirstAvailableHypervisorNodeFromTemplates(userLab.Lab.LabVms));
foreach (var bridgeTemplate in userLab.Lab.BridgeTemplates)
{
userLab.BridgeInstances.Add(new BridgeInstance
{
HypervisorInterfaceId = await api.CreateBridge(),
BridgeTemplate = bridgeTemplate,
});
}
foreach (var labVm in userLab.Lab.LabVms)
{
var template = labVm.GetTemplateWithNode(api.HypervisorNode);
int createdVmId = await api.CloneTemplate(node, template.TemplateVmId);
userLab.UserLabVms.Add(new UserLabVm
{
LabVm = labVm,
ProxmoxVmId = createdVmId,
HypervisorVmTemplate = template,
IsCoreRouter = template.VmTemplate.IsCoreRouter
});
}
foreach (var vm in userLab.UserLabVms)
{
await LinkVmToBridgesAndAddInstances(userLab, vm, api, node);
}
await api.ApplyNetworkConfiguration();
foreach (var vm in userLab.UserLabVms)
{
await api.StartVM(vm.ProxmoxVmId, node.Name);
}
userLab.HypervisorNode = node;
userLab.EndDateTime = DateTime.UtcNow.AddDays(30);
userLab.Status = EUserLabStatus.Started;
}
public async Task <IActionResult> TurnOn(int id)
{
var userLab = await DatabaseContext.UserLabs
.IncludeRelations()
.IncludeLabHypervisor()
.Include(ul => ul.Lab)
.FirstAsync(ul => ul.Id == id);
var api = ProxmoxManager.GetProxmoxApi(userLab);
foreach (var userLabVm in userLab.UserLabVms)
{
if ((await api.GetVmStatus(userLabVm.ProxmoxVmId)).IsStopped())
{
await api.StartVM(userLabVm.ProxmoxVmId);
}
}
return(Ok());
}
public async Task <IActionResult> ProcessLastUsed()
{
var userLabs = await DatabaseContext.UserLabs
.IncludeHypervisor()
.Include(l => l.UserLabVms)
.Where(l => l.LastUsed != null && l.LastUsed < DateTime.UtcNow.AddMinutes(-30))
.ToListAsync();
foreach (var userLab in userLabs)
{
var api = ProxmoxManager.GetProxmoxApi(userLab);
userLab.LastUsed = null;
await DatabaseContext.SaveChangesAsync();
foreach (var userLabVm in userLab.UserLabVms)
{
await api.StopVM(userLabVm.ProxmoxVmId);
}
}
return(Ok());
}
public ProxmoxVmTemplateService(ProxmoxManager manager)
{
ProxmoxManager = manager;
}
