public async Task <int> UploadVmTemplate(
string name,
Stream fileStream,
long length,
Hypervisor hypervisor,
VmTemplate vmTemplate,
Action <double> callback = null)
{
var safeFileName = vmTemplate.Id + ".ova";
const string baseDir = "/root/uploads";
var dirName = "VmTemplate_" + vmTemplate.Id;
var dirPath = string.Join("/", baseDir, dirName);
var filePath = string.Join("/", dirPath, safeFileName);
var node = await ProxmoxManager.GetPrimaryHypervisorNode(hypervisor);
var api = ProxmoxManager.GetProxmoxApi(node);
int vmId;
// Upload File
using (var sftp = new SftpClient(GetConnectionInfoFromHypervisor(hypervisor)))
{
sftp.Connect();
try
{
sftp.CreateDirectory(dirPath);
sftp.ChangeDirectory(dirPath);
sftp.UploadFile(fileStream, filePath, true, progress =>
{
if (callback != null)
{
callback((double)progress / length * 100);
}
});
using (var ssh = new SshClient(GetConnectionInfoFromHypervisor(hypervisor)))
{
ssh.Connect();
await ExtractOva(ssh, filePath, dirPath);
vmId = await CreateVmAndImportDisk(name, ssh, sftp, api, dirPath);
var unusedDisk = await api.GetVmUnusedDisk(vmId);
await api.SetVmScsi0(vmId, unusedDisk);
await api.ConvertVmToTemplate(vmId);
ssh.Disconnect();
}
Cleanup(sftp, dirPath);
}
catch (Exception)
{
Cleanup(sftp, dirPath);
throw;
}
sftp.Disconnect();
}
return(vmId);
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
Badge.OnModelCreating(builder);
User.OnModelCreating(builder);
// module section
Module.OnModelCreating(builder);
Lab.OnModelCreating(builder);
LabVm.OnModelCreating(builder);
UserModule.OnModelCreating(builder);
// user module section
UserModule.OnModelCreating(builder);
UserLab.OnModelCreating(builder);
UserLabVm.OnModelCreating(builder);
// hypervisor
Hypervisor.OnModelCreating(builder);
HypervisorNode.OnModelCreating(builder);
// configure many to many relationship
UserUserModule.OnModelCreating(builder);
ContactEmail.OnModelCreating(builder);
BridgeInstance.OnModelCreating(builder);
VmInterfaceTemplate.OnModelCreating(builder);
VmInterfaceInstance.OnModelCreating(builder);
BridgeTemplate.OnModelCreating(builder);
VmTemplate.OnModelCreating(builder);
}
public ActionResult Edit(Hypervisor hypervisor)
{
if (ModelState.IsValid)
{
hypervisor.LastUpdated = DateTime.Now;
if (hypervisor.Inactive)
{
if (hypervisor.InactiveDate == null)
{
hypervisor.InactiveDate = hypervisor.LastUpdated;
}
}
else
{
if (hypervisor.InactiveDate != null)
{
hypervisor.InactiveDate = null;
}
}
this.db.Hypervisors.Attach(hypervisor);
this.db.ObjectStateManager.ChangeObjectState(hypervisor, EntityState.Modified);
this.db.SaveChanges();
return(this.RedirectToAction("Details", new { id = hypervisor.Id }));
}
ViewBag.HypervisorGroup_Id_Select = new SelectList(this.db.HypervisorGroups.OrderBy(x => x.Name), "Id", "Name", hypervisor.HypervisorGroup_Id);
ViewBag.HypervisorType_Id_Select = new SelectList(this.db.HypervisorTypes.OrderBy(x => x.Name), "Id", "Name", hypervisor.HypervisorType_Id);
ViewBag.HypervisorWorkloadProfile_Id_Select = new SelectList(this.db.HypervisorWorkloadProfiles.OrderBy(x => x.Name), "Id", "Name", hypervisor.HypervisorWorkloadProfile_Id);
return(this.View(hypervisor));
}
public Hypervisor Update(Hypervisor hv)
{
using (dbc = DAL.Instance.GetDb()){
dbc.Update <Hypervisor>(hv);
}
return(hv);
}
public async Task <HypervisorNode> GetLeastLoadedHyperVisorNode(Hypervisor hypervisor, int estimatedMemoryUsedMb)
{
long requiredMemoryBytes = estimatedMemoryUsedMb * 1024 * 1204;
// only support one cluster right now
var hypervisorNodes = _context.HypervisorNodes
.Where(n => n.HypervisorId == hypervisor.Id)
.Include(n => n.Hypervisor)
.ToList();
var api = GetProxmoxApi(hypervisorNodes.First());
var list = new List <KeyValuePair <NodeStatus, HypervisorNode> >();
foreach (var hypervisorNode in hypervisorNodes)
{
var nodeStatus = await api.GetNodeStatus(hypervisorNode);
list.Add(new KeyValuePair <NodeStatus, HypervisorNode>(nodeStatus, hypervisorNode));
}
list = list.Where(p => p.Key.MemoryUsage.Free > requiredMemoryBytes).ToList();
list.Sort((s1, s2) => (int)((s1.Key.CpuUsage - s2.Key.CpuUsage) * 100));
if (list.Count == 0)
{
throw new NoHypervisorAvailableException();
}
return(list.First().Value);
}
public async Task TestConnect(Hypervisor hypervisor)
{
using (var ssh = new SshClient(GetConnectionInfoFromHypervisor(hypervisor)))
{
ssh.Connect();
ssh.Disconnect();
}
}
public ActionResult DeleteConfirmed(Guid id)
{
Hypervisor hypervisor = this.db.Hypervisors.Single(h => h.Id == id);
this.db.Hypervisors.DeleteObject(hypervisor);
this.db.SaveChanges();
return(this.RedirectToAction("Index"));
}
public ConnectionInfo GetConnectionInfoFromHypervisor(Hypervisor hypervisor)
{
var host = hypervisor.Host;
var username = hypervisor.UserName;
var password = ProxmoxManager.GetProxmoxPassword(hypervisor);
return(new ConnectionInfo(host, username, new PasswordAuthenticationMethod(username, password)));
}
public override string Second(string input)
{
Hypervisor hv = new Hypervisor();
hv.Boot(input);
hv.Execute();
return(hv.Alus[1].SendCount.ToString());
}
public Hypervisor Save(Hypervisor hv)
{
hv.Id = IdManager.GetId();
using (dbc = DAL.Instance.GetDb()){
dbc.Insert <Hypervisor>(hv);
}
return(hv);
}
public Hypervisor GetById(int id)
{
using (dbc = DAL.Instance.GetDb()){
Hypervisor hv = dbc.Select <Hypervisor>(h => h.Id == id)[0];
hv.Password = PasswordManager.Get(hv.PasswordId);
return(hv);
}
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="HypervisorListIndexViewModel"/> class.
/// </summary>
/// <param name="model">The Hypervisor to reference.</param>
/// <param name="activeVirtualMachineCount">The number of active
/// Virtual Machines related to the Hypervisor.</param>
private HypervisorListIndexViewModel(Hypervisor model, int activeVirtualMachineCount)
: base(model)
{
// Properties from the entity, notes and tags.
this.ReadEntityProperties(model);
// Related entities.
this.ActiveVirtualMachineCount = activeVirtualMachineCount;
}
void Awake()
{
if (instance != null)
{
Destroy(gameObject);
return;
}
instance = this;
DontDestroyOnLoad(gameObject);
}
private void SendToQueue()
{
if (FirmwareVersion == 2)
{
if (HasRegValue(_SEND))
{
Hypervisor.Send(this, GetRegValue(_SEND));
SendCount++;
RemoveRegValue(_SEND);
}
}
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="HypervisorListIndexViewModel"/> class.
/// </summary>
/// <param name="model">The Hypervisor to reference.</param>
public HypervisorListIndexViewModel(Hypervisor model)
: base(model)
{
// Properties from the entity, notes and tags.
this.ReadEntityProperties(model);
// Related entities.
this.ActiveVirtualMachineCount = model.VirtualMachines
.Where(z => !z.Inactive)
.GroupBy(x => x.Id)
.Select(x => x.FirstOrDefault())
.Count();
}
public ActionResult Edit(Guid id)
{
Hypervisor hypervisor = this.db.Hypervisors.Single(h => h.Id == id);
if (hypervisor == null)
{
return(this.HttpNotFound());
}
ViewBag.HypervisorGroup_Id_Select = new SelectList(this.db.HypervisorGroups.OrderBy(x => x.Name), "Id", "Name", hypervisor.HypervisorGroup_Id);
ViewBag.HypervisorType_Id_Select = new SelectList(this.db.HypervisorTypes.OrderBy(x => x.Name), "Id", "Name", hypervisor.HypervisorType_Id);
ViewBag.HypervisorWorkloadProfile_Id_Select = new SelectList(this.db.HypervisorWorkloadProfiles.OrderBy(x => x.Name), "Id", "Name", hypervisor.HypervisorWorkloadProfile_Id);
return(this.View(hypervisor));
}
public override async Task Run(AddHypervisorOptions options)
{
var hypervisor = new Hypervisor
{
Host = options.Host,
UserName = options.UserName,
NoVncUrl = options.NoVncUrl,
Password = Cryptography.EncryptString(options.Password, _encryptionKey)
};
_context.Hypervisors.Add(hypervisor);
await _context.SaveChangesAsync();
System.Console.WriteLine("Added Hypervisor:");
System.Console.WriteLine(JsonConvert.SerializeObject(hypervisor));
}
private async Task <Hypervisor> WriteHypervisorToDbAsync(string hypervisor, string backupTask)
{
var hyperV = await FindHypervisorByName(hypervisor);
if (hyperV == null)
{
hyperV = new Hypervisor();
hyperV.Name = hypervisor.ToLower();
hyperV.BackupTask = backupTask;
_context.Hypervisors.Add(hyperV);
await _context.SaveChangesAsync();
}
return(hyperV);
}
/// <summary>
/// Populates properties on the view model from an instance of the
/// Hypervisor class.
/// </summary>
/// <param name="model">The Hypervisor to reference.</param>
private void ReadEntityProperties(Hypervisor model)
{
// Properties from the entity.
this.Memory = model.Memory;
this.ProcessorCores = model.ProcessorCores;
this.CreatedDate = model.CreatedDate;
this.LastUpdated = model.LastUpdated;
this.InactiveDate = model.InactiveDate;
this.IPAddress = model.IPAddress;
this.Status = model.Status;
this.SiteLocation = model.SiteLocation;
this.HyperVisorVersion = model.HyperVisorVersion;
// Related entities.
this.HypervisorType = model.HypervisorType;
// TODO: Remove Hypervisor Workload Profile.
this.HypervisorWorkloadProfile = model.HypervisorWorkloadProfile;
if (model.HypervisorGroup != null)
{
this.HypervisorGroup = new HypervisorGroupReferenceViewModel(model.HypervisorGroup);
}
else
{
this.HypervisorGroup = null;
}
// IHasCapacity Members.
this.TotalCapacity = model.TotalCapacity;
this.UsedCapacity = model.UsedCapacity;
this.UsedCapacityPercent = model.UsedCapacityPercent;
// Notes and Tags.
this.Notes = model.Notes
.OrderByDescending(x => x.CreatedAt)
.AsEnumerable()
.Select(x => new NoteDetailsViewModel(x))
.ToList();
this.Tags = model.TagsMetas
.OrderBy(x => x.Tag.Name)
.AsEnumerable()
.Select(x => new TagDetailsViewModel(x))
.ToList();
}
public ActionResult Create(Hypervisor hypervisor)
{
if (ModelState.IsValid)
{
hypervisor.Id = Guid.NewGuid();
hypervisor.CreatedDate = DateTime.Now;
hypervisor.LastUpdated = hypervisor.CreatedDate;
this.db.Hypervisors.AddObject(hypervisor);
this.db.SaveChanges();
return(this.RedirectToAction("Details", new { id = hypervisor.Id }));
}
ViewBag.HypervisorGroup_Id_Select = new SelectList(this.db.HypervisorGroups.OrderBy(x => x.Name), "Id", "Name", hypervisor.HypervisorGroup_Id);
ViewBag.HypervisorType_Id_Select = new SelectList(this.db.HypervisorTypes.OrderBy(x => x.Name), "Id", "Name", hypervisor.HypervisorType_Id);
ViewBag.HypervisorWorkloadProfile_Id_Select = new SelectList(this.db.HypervisorWorkloadProfiles.OrderBy(x => x.Name), "Id", "Name", hypervisor.HypervisorWorkloadProfile_Id);
return(this.View(hypervisor));
}
public Alu(Hypervisor hypervisor, int aluRef, string input, int firmwareVersion = 1)
{
Hypervisor = hypervisor;
AluRef = aluRef;
FirmwareVersion = firmwareVersion;
Registers = new Dictionary <string, long>();
SendCount = 0;
Ptr = 0;
ReceiveQueue = new Queue <long>();
var lines = GetLines(input);
Instructions = new Instruction[lines.Length];
foreach (var line in lines)
{
Instructions[Ptr++] = Instruction.GetInstruction(line, firmwareVersion);
}
Ptr = 0;
}
/// <summary>
/// Determines the best Hypervisor from the List of managed Hypervisors for the Vm <paramref name="vm"/> and adds the Vm to it.
/// </summary>
/// <param name="vm">The Vm that should be added to one of the managed Hypervisors</param>
public void AddVm(Vm vm)
{
// Find the Hypervisor, where adding the Vm leads to the best result (equally distributed load).
Hypervisor bestCandidate = FindBestHypervisor(vm);
if (bestCandidate != null)
{
// update number of free Hypervisors (Hypervisors without any Vm)
if (bestCandidate.CurrentLoadAbsolute == 0)
{
_numFreeHypervisors--;
}
// Add the Vm to the Hypervisor.
bestCandidate.AddVm(vm);
}
else
{
// No Hypervisor with enough capacity for the Vm found.
Console.WriteLine($"WARNING - not enough free capacity for adding Vm {vm.Id}");
}
}
/// <summary>
/// Populates properties on the view model from an instance of the
/// Hypervisor class.
/// </summary>
/// <param name="model">The Hypervisor to reference.</param>
private void ReadEntityProperties(Hypervisor model)
{
// Related entities.
this.HypervisorType = model.HypervisorType;
if (model.HypervisorGroup != null)
{
this.HypervisorGroup = new HypervisorGroupReferenceViewModel(model.HypervisorGroup);
}
else
{
this.HypervisorGroup = null;
}
// IHasCapacity Members.
this.TotalCapacity = model.TotalCapacity;
this.UsedCapacity = model.UsedCapacity;
this.UsedCapacityPercent = model.UsedCapacityPercent;
// Notes and Tags.
this.Notes = new NoteCollectionListViewModel(model.Notes);
this.Tags = new TagCollectionListViewModel(model.TagsMetas);
}
/// <summary>
/// Finds the best matching Hypervisor for a Vm out of the List of managed Hypervisors.
/// This is done by assigning the Vm to each Hypervisor consecutively and calculating the average deviation from the average load
/// this would cause. Then the Hypervisor that causes the best result (lowest overall deviation) will be picked.
/// </summary>
/// <param name="vm">The Vm for which the best matching Hypervisor should be found.</param>
/// <returns></returns>
private Hypervisor FindBestHypervisor(Vm vm)
{
Hypervisor result = null;
// temporary array to calculate the overall-deviation for each candidate without changing the Hypervisors current load.
double[] tmpLoad = _managedHypervisors.Select(hv => hv.CurrentLoadPercent).ToArray();
double lowestDeviation = 100;
for (var i = 0; i < _managedHypervisors.Count; i++)
{
var hv = _managedHypervisors[i];
// Only if the remaining capacity is large enough for the new Vm
if (hv.CheckIfVmFits(vm))
{
// calculate the new load of the Hypervisor after adding this Vm.
tmpLoad[i] = hv.CalcLoadAfterAddingVm(vm);
// Calculate the average load of all (non empty) hypervisors,
// and the average deviation from the average load for all Hypervisors.
var tmpAverage = tmpLoad.Sum() / tmpLoad.Where(l => l > 0).Count();
var tmpAverageDeviation = tmpLoad.Select(l => Math.Abs(tmpAverage - l)).Sum() / tmpLoad.Length;
// restore the load to its original value for the next iteration.
tmpLoad[i] = hv.CurrentLoadPercent;
// Find the lowest overall deviation. If the deviation caused by this Hypervisor is equal to the
// lowest deviation so far, the Hypervisor with the lower load after adding the Vm is chosen.
if ((tmpAverageDeviation < lowestDeviation) ||
(tmpAverageDeviation == lowestDeviation && result.CalcLoadAfterAddingVm(vm) > hv.CalcLoadAfterAddingVm(vm)))
{
lowestDeviation = tmpAverageDeviation;
result = hv;
}
}
}
return(result);
}
private async Task WriteVirtualMachinesToDbAsync(Hypervisor hyperV, List <string> virtualMachines)
{
if (virtualMachines == null || virtualMachines.Count == 0)
{
return;
}
if (hyperV.VirtualMachines != null && hyperV.VirtualMachines.Count > 0)
{
var machinesInDb = hyperV.VirtualMachines.Select(m => m.Name);
virtualMachines = virtualMachines.Except(machinesInDb, StringComparer.OrdinalIgnoreCase)
.ToList();
}
foreach (var machine in virtualMachines)
{
var vm = new VirtualMachine();
vm.Hypervisor = hyperV;
vm.Name = machine;
_context.VirtualMachines.Add(vm);
}
await _context.SaveChangesAsync();
}
public void DeleteHypervisor(Hypervisor hv)
{
new DAL.HypervisorDAO().Delete(hv);
}
public async Task <HypervisorNode> GetPrimaryHypervisorNode(Hypervisor hypervisor)
{
return(await _context.HypervisorNodes
.Where(n => n.HypervisorId == hypervisor.Id && n.Primary)
.FirstAsync());
}
public string GetProxmoxPassword(Hypervisor hypervisor)
{
return(Cryptography.DecryptString(hypervisor.Password, _encryptionKey));
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="HypervisorReferenceViewModel" /> class.
/// </summary>
/// <param name="model">The Hypervisor to
/// reference.</param>
public HypervisorReferenceViewModel(Hypervisor model)
{
this.Id = model.Id;
this.Name = model.Name;
this.Inactive = model.Inactive;
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="HypervisorDetailsViewModel"/> class.
/// </summary>
/// <param name="model">The Hypervisor to reference.</param>
public HypervisorDetailsViewModel(Hypervisor model)
: base(model)
{
// Properties from the entity, notes and tags.
this.ReadEntityProperties(model);
}
