public VirtualMachine CreateVM()
{
if (RegisteredVirtualMachineService.GetRegisteredVMImagePaths().Contains(VM.ImagePathName))
throw new InvalidDataException("Specified VM path already exists");
if (!VM.ImagePathName.StartsWith(AppConfiguration.GetDatastore()) || VM.BaseImageFullPhysicalPath.StartsWith(AppConfiguration.GetDatastore()))
throw new InvalidDataException("Invalid ImagePathName: doesn't contain datastore name, or BaseImageFullPhysicalPath does contain datastore name");
if (VM.ImagePathName.Length < 8 || VM.BaseImageFullPhysicalPath.Length < 8 || VM.IP.Length < 7)
throw new InvalidDataException("CreateVM required field unspecified or too short");
//this will run async, but probably should report status and handle errors in individual steps better
try
{
CopyVMFiles(VM.BaseImageFullPhysicalPath, VM.ImagePathName);
}
catch (Exception ex)
{
throw new SchedulerInfo("Error copying files, VM creation aborted.", ex);
}
// Allot time to finish copying the file
System.Threading.Thread.Sleep(16 * 1000);
RegisteredVirtualMachineService service = null;
try
{
RegisteredVirtualMachineService.GetVirtualHost().Register(VM.ImagePathName);
service = new RegisteredVirtualMachineService(VM.ImagePathName);
// Make triple-double-dog sure that the VM is online and ready.
// Allow VM time to power on
service.PowerOn();
System.Threading.Thread.Sleep(180 * 1000);
// Allow VM time to reboot
service.Reboot();
System.Threading.Thread.Sleep(250 * 1000);
}
catch (Exception ex)
{
new SchedulerInfo("Error registering or first-booting new VM, will attempt to continue", ex).LogElmah();
}
SetIPHostname(service);
// Allow VM time to reboot
service.Reboot();
System.Threading.Thread.Sleep(250 * 1000);
if (!VM.IsAutoStarted)
service.PowerOff();
return VM;
//http://vmwaretasks.codeplex.com/discussions/276715
//"[ha-datacenter/standard] Windows Server 2003/Windows Server 2003.vmx"
//http://communities.vmware.com/message/1688542#1688542
//http://panoskrt.wordpress.com/2009/01/20/clone-virtual-machine-on-vmware-server-20/
//we don't seem to have vmware-vdiskmanager
}
public void PowerOnTest()
{
VirtualMachineRepository vmr = new VirtualMachineRepository();
VirtualMachine vm = vmr.GetAllRegisteredVirtualMachines().GetEnumerator().Current; // TODO: Initialize to an appropriate value
RegisteredVirtualMachineService target = new RegisteredVirtualMachineService(vm); // TODO: Initialize to an appropriate value
if (target.GetStatus() == VirtualMachine.STOPPED)
{
target.PowerOn();
Assert.IsTrue(target.GetStatus() == VirtualMachine.POWERINGON || target.GetStatus() == VirtualMachine.RUNNING);
}
else
Assert.Inconclusive();
}
public void PauseTest()
{
VirtualMachineRepository vmr = new VirtualMachineRepository();
VirtualMachine vm = vmr.GetAllRegisteredVirtualMachines().GetEnumerator().Current; // TODO: Initialize to an appropriate value
RegisteredVirtualMachineService target = new RegisteredVirtualMachineService(vm); // TODO: Initialize to an appropriate value
if (target.GetStatus() == VirtualMachine.RUNNING)
{
target.Pause();
Assert.Equals(target.GetStatus(), VirtualMachine.PAUSED);
}
else
Assert.Inconclusive();
}
public static void ArchivePendingVMs()
{
var ls = dataDB.VirtualMachines.Where(v => v.IsPendingArchive);
foreach (var pendingVM in ls)
{
new SchedulerInfo("Beginning archive of project " + pendingVM.Hostname).LogElmah();
var service = new ArchiveVirtualMachineService();
try
{
//TODO insert archiving code
RegisteredVirtualMachineService rvms = new RegisteredVirtualMachineService(pendingVM);
rvms.PowerOff();
string vmFilename = RegisteredVirtualMachineService.ConvertPathToPhysical(pendingVM.ImagePathName);
vmFilename = vmFilename.Substring(0, vmFilename.LastIndexOf('\\'));
if (!Models.VirtualMachine.ArchiveFile(vmFilename, vmFilename + ".7z"))
{
//It was a failure
//IMPORTANT: if it fails, should it not continue?
new SchedulerInfo("VM archiving failed").LogElmah();
}
}
catch (Exception ex)
{
new SchedulerInfo("Uncaught VM archive error", ex).LogElmah();
}
//important: if that excepts, this should probably still continue?
try
{
dataDB.VirtualMachines.Remove(pendingVM);
//TODO create & add an ArchivedVM
//dataDB.VirtualMachines.Add(regVM);
}
catch (Exception ex)
{
new SchedulerInfo("Error updating database post-VM archive, may need manual modification", ex).LogElmah();
}
try
{
dataDB.SaveChanges();
}
catch (Exception ex)
{
new SchedulerInfo("Error updating database post-VM archive, may need manual modification", ex).LogElmah();
}
}
new SchedulerInfo("All archiving completed").LogElmah();
}
public void ToggleVMStatusTest()
{
VirtualMachineRepository target = new VirtualMachineRepository(); // TODO: Initialize to an appropriate value
VirtualMachine vm = target.GetAllRegisteredVirtualMachines().GetEnumerator().Current;
var service = new RegisteredVirtualMachineService(vm.ImagePathName);
if (service.IsRunning())
{
int status = target.ToggleVMStatus(vm.VirtualMachineId);
Assert.IsTrue(status == VirtualMachine.STOPPED || status == VirtualMachine.POWERINGOFF);
}
else
{
int status = target.ToggleVMStatus(vm.VirtualMachineId);
Assert.IsTrue(status == VirtualMachine.RUNNING || status == VirtualMachine.POWERINGON);
}
}
private void PowerOn(VirtualMachine vm, RegisteredVirtualMachineService service)
{
vm.Status = VirtualMachine.POWERINGON;
dataDB.SaveChanges();
service.PowerOn();
vm.Status = VirtualMachine.RUNNING;
vm.LastStarted = DateTime.Now;
dataDB.SaveChanges();
}
private void PowerOff(VirtualMachine vm, RegisteredVirtualMachineService service)
{
vm.Status = VirtualMachine.POWERINGOFF;
dataDB.SaveChanges();
service.PowerOff();
vm.Status = VirtualMachine.STOPPED;
vm.LastStopped = DateTime.Now;
dataDB.SaveChanges();
}
private void InitializeDataContext()
{
var registeredImages = RegisteredVirtualMachineService.GetRegisteredVMImagePaths();
foreach (var image in registeredImages)
{
int startIndex = image.IndexOf("] ") + "] ".Length;
int length = image.IndexOf('/', startIndex) - startIndex;
string projectName = image.Substring(startIndex, length);
var service = new RegisteredVirtualMachineService(image);
if (!dataDB.Projects.Select(p => p.ProjectName).Contains(projectName))
{
var project = new Project(projectName);
dataDB.Projects.Add(project);
dataDB.SaveChanges();
}
startIndex = image.LastIndexOf('/') + 1;
length = image.LastIndexOf('.') - startIndex;
string machineName = image.Substring(startIndex, length);
VirtualMachine vm;
try
{
vm = dataDB.VirtualMachines.Single(v => v.MachineName == machineName);
}
catch (Exception)
{
vm = new VirtualMachine();
dataDB.VirtualMachines.Add(vm);
}
//PowerOn(vm, service);
vm.MachineName = machineName;
vm.ImagePathName = image;
vm.Status = service.GetStatus();
//TODO reset
//vm.Hostname = "test-hostname";
vm.Hostname = service.GetHostname();
vm.IP = service.GetIP();
vm.Project = dataDB.Projects.Single(p => p.ProjectName == projectName);
dataDB.SaveChanges();
}
}
public int ToggleVMStatus(int id)
{
VirtualMachine vm = dataDB.VirtualMachines.Single(d => d.VirtualMachineId == id);
var service = new RegisteredVirtualMachineService(vm.ImagePathName);
if (service.IsRunning())
PowerOff(vm, service);
else
PowerOn(vm, service);
return vm.Status;
}
public void ReinitializeAllRegisteredVirtualMachines()
{
var imagePathNames = RegisteredVirtualMachineService.GetRegisteredVMImagePaths();
foreach (var image in imagePathNames)
{
int startIndex = image.IndexOf("] ") + "] ".Length;
int length = image.IndexOf('/', startIndex) - startIndex;
string projectName = image.Substring(startIndex, length);
var service = new RegisteredVirtualMachineService(image);
if (!dataDB.Projects.Select(p => p.ProjectName).Contains(projectName))
{
var project = new Project(projectName);
dataDB.Projects.Add(project);
dataDB.SaveChanges();
}
startIndex = image.LastIndexOf('/') + 1;
length = image.LastIndexOf('.') - startIndex;
string machineName = image.Substring(startIndex, length);
if (!dataDB.VirtualMachines.Select(v => v.MachineName).Contains(machineName))
{
VirtualMachine vm = new VirtualMachine();
vm.MachineName = machineName;
vm.ImagePathName = image;
vm.Status = service.GetStatus();
vm.Hostname = service.GetHostname();
vm.IP = service.GetIP();
vm.Project = dataDB.Projects.Single(p => p.ProjectName == projectName);
dataDB.VirtualMachines.Add(vm);
dataDB.SaveChanges();
}
}
}
public ICollection<Project> GetAllProjects()
{
foreach (var vm in dataDB.VirtualMachines.Where(v => v.Status != VirtualMachine.ARCHIVED &&
v.Status != VirtualMachine.PENDING))
{
RegisteredVirtualMachineService service = null;
try
{
service = new RegisteredVirtualMachineService(vm.ImagePathName);
}
catch (Vestris.VMWareLib.VMWareException)
{
dataDB.VirtualMachines.Remove(vm);
continue;
}
vm.Status = service.GetStatus();
if (vm.IP == null && vm.Status == VirtualMachine.RUNNING)
vm.IP = service.GetIP();
if (vm.Hostname == null && vm.Status == VirtualMachine.RUNNING)
vm.Hostname = service.GetHostname();
}
dataDB.SaveChanges();
return dataDB.Projects.ToList();
}
public void SetHostnameTest()
{
VirtualMachineRepository vmr = new VirtualMachineRepository();
VirtualMachine vm = vmr.GetAllRegisteredVirtualMachines().GetEnumerator().Current; // TODO: Initialize to an appropriate value
RegisteredVirtualMachineService target = new RegisteredVirtualMachineService(vm); // TODO: Initialize to an appropriate value
string hostname = string.Empty; // TODO: Initialize to an appropriate value
target.SetHostname(hostname);
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
public void SetIPTest()
{
VirtualMachineRepository vmr = new VirtualMachineRepository();
VirtualMachine vm = vmr.GetAllRegisteredVirtualMachines().GetEnumerator().Current; // TODO: Initialize to an appropriate value
RegisteredVirtualMachineService target = new RegisteredVirtualMachineService(vm); // TODO: Initialize to an appropriate value
string oldIP = target.GetIP();
//set the new IP to the same first several sets of characters, but change the last few
string value = oldIP.Substring(0, oldIP.LastIndexOf('.')) + ".200";
target.SetIP(value);
string newIP = target.GetIP();
target.SetIP(oldIP);
Assert.Equals(newIP, value);
}
private void SetIPHostname(RegisteredVirtualMachineService service, bool retry = true)
{
try
{
System.Threading.Thread.Sleep(12 * 1000);
service.SetHostname(VM.Hostname);
System.Threading.Thread.Sleep(8 * 1000);
service.SetIP(VM.IP.ToString());
System.Threading.Thread.Sleep(8 * 1000);
}
catch (Exception ex)
{
if (retry) SetIPHostname(service, false);
else new SchedulerInfo("Error setting IP or hostname of new VM, will need to be manually set but will continue", ex).LogElmah();
}
}