static void Test_CreateVmExisting(Host host)
{
//Get vm iso
XenConnect conn = new XenConnect(host, testServerId, testip);
List <VirtualDisk> disks = conn.getISOStorageList();
string filename = null;
//check if the disk exists
foreach (VirtualDisk disk in disks)
{
if (disk.NameCanonical.Contains("Ubuntu14"))
{
filename = disk.Name;
break;
}
}
string vmName = "SeniorBuntu";
int memory = 2000000;
int vcpus = 1;
VirtualMachineBuilder.DomainType domType = VirtualMachineBuilder.DomainType.TRANSIENT;
VirtualMachineBuilder builder = new VirtualMachineBuilder(vmName, memory, vcpus, VirtualMachineBuilder.XEN_PATH_DEFAULT_ISO + filename, domType);
//builder.setHardDrive(20000, true); //set hard drive size to 20 GB (20k MB)
builder.setHardDriveExisting(true, false, VirtualMachineBuilder.XEN_PATH_DEFAULT_DISK + "BuntuMaster.img");
conn.createVm(builder);
//string xml = builder.toXMLString();
}
public void getHOst()
{
XenConnect hostConnect = new XenConnect("172.16.10.115", 29171, "172.16.10.76", "VMAX");
XenMaster.XenMaster master = new XenMaster.XenMaster(hostConnect);
master.connect();
}
static void Test_GetVNCPort(Host host, string uuid)
{
XenConnect conn = new XenConnect(host, testServerId, testip);
int portNum;
conn.getVmVNCPort(uuid, out portNum);
}
private static void Test_GetHostDiskusage(Host host)
{
XenConnect conn = new XenConnect(host, testServerId, testip);
List <DiskStatistic> stats = null;
conn.getHostDiskUsage(out stats);
}
static void Test_CreateVm(Host host)
{
//Get vm iso
XenConnect conn = new XenConnect(host, testServerId, testip);
conn.SendHeartBeat();
}
static void Test_GetProcessList(Host host, string vmName)
{
XenConnect conn = new XenConnect(host, testServerId, testip);
List <Processes> vmProcesses = null;
conn.getVmProcessList(vmName, out vmProcesses);
}
static void Test_ListVMStatistics(Host host, string uuid)
{
XenConnect conn = new XenConnect(host, testServerId, testip);
List <VcpuInfo> info = null;
conn.listVmStats(uuid, out info);
}
private void updatePerformance(Host host)
{
XenConnect conn = new XenConnect(host, Settings.SystemIdentifier, Settings.SystemIp);
foreach (KeyValuePair <string, VM> kvp in host.VMList)
{
VM vm = kvp.Value;
if (vm.PowerState == vm_state.Shutoff)
{
continue;
}
List <VcpuInfo> cpuinfo = null;
conn.listVmStats(vm.UUID, out cpuinfo);
if (cpuinfo == null)
{
continue;
}
int cpuCount = 0;
ulong cpuTime = 0;
foreach (VcpuInfo info in cpuinfo)
{
cpuCount++;
cpuTime += info.CpuTime;
}
listview_performance.Items.Add(new UserControl1(cpuCount, cpuTime, vm.Name));
}
}
public void updateVMCpuInfo()
{
foreach (KeyValuePair <string, Host> entry in _hostList)
{
Host host = entry.Value;
foreach (KeyValuePair <string, VM> vmentry in host.VMList)
{
VM vm = vmentry.Value;
if (!(vm.PowerState == vm_state.Running))
{
continue;
}
XenConnect connect = new XenConnect(host, "VMAX", "172.16.10.76"); //TODO: Unhardcode me please!
List <VcpuInfo> info = null;
connect.listVmStats(vm.UUID, out info);
if (info == null)
{
continue;
}
Application.Current.Dispatcher.Invoke((Action) delegate
{
vm.updateVcpuStats(info);
});
Thread.Sleep(1000);
}
}
}
static void Test_FileTransfer(Host host, string file, string remoteDirectory)
{
XenConnect conn = new XenConnect(host, testServerId, testip);
FileStream fs = File.Open(file, FileMode.Open, FileAccess.Read);
long size = fs.Length;
fs.Close();
conn.transferFile(file, remoteDirectory, size);
}
public void updateHostsVMList()
{
foreach (KeyValuePair <string, Host> entry in _hostList)
{
Host host = entry.Value;
XenConnect connect = new XenConnect(host, "VMAX", "172.16.10.76"); //TODO: Unhardcode me please!
VirtualMachineList vms = connect.getHostVirtualMachineList();
host.setVMList(vms);
}
}
private void updateHostDisksList(Host host)
{
XenConnect conn = new XenConnect(host, Settings.SystemIdentifier, Settings.SystemIp);
conn.Notifications += e_logXenMasterNotification;
List <VirtualDisk> isoImages = conn.getISOStorageList();
List <VirtualDisk> vmDisks = conn.getVirtualDiskList();
listview_host_disks.ItemsSource = vmDisks;
listview_host_images.ItemsSource = isoImages;
}
private void remoteView(Host host, VM vm)
{
XenConnect conn = new XenConnect(host, Settings.SystemIdentifier, Settings.SystemIp);
conn.Notifications += e_logXenMasterNotification;
int vmVncPort;
conn.getVmVNCPort(vm.UUID, out vmVncPort);
VMViewerWindow viewerWindow = new VMViewerWindow(host, vm, vmVncPort);
viewerWindow.Show();
}
private void ComboBox_Host_DropDownClosed(object sender, EventArgs e)
{
//MessageBox.Show(combobox_host.Text);
_selectedHost = getHostByName(combobox_host.Text);
XenConnect conn = new XenConnect(_selectedHost, _settings.SystemIdentifier, _settings.SystemIp);
List <VirtualDisk> isoImages = conn.getISOStorageList();
combobox_os_image.Items.Clear();
foreach (VirtualDisk disk in isoImages)
{
combobox_os_image.Items.Add(disk.NameCanonical);
}
}
static void Test_GetHostDetails(Host host)
{
Console.WriteLine("Retrieving host details...");
XenConnect con = new XenConnect(host, testServerId, testip);
XenError status = con.getHostDetails();
if (status.Type == XenError.XenErrorType.SUCCESS)
{
Console.WriteLine("Host details retrieved successfully");
}
else
{
Console.WriteLine("Unable to retrieve the hosts details " + status.Message);
}
}
static void Test_ResumeVM(Host host, string uuid)
{
Console.WriteLine("Resuming virtual machine with uuid " + uuid);
XenConnect con = new XenConnect(host, testServerId, testip);
XenError status = con.resumeVm(uuid);
if (status.Type == XenError.XenErrorType.SUCCESS)
{
Console.WriteLine("VM with uuid " + uuid + " resumed successfully");
}
else
{
Console.WriteLine("Unable to resume vm with uuid " + uuid + " " + status.Message);
}
}
/*
* private static void Test_ListMalware(Host host)
* {
* XenConnect conn = new XenConnect(host, testServerId, testip);
*
* List<Application> malwareList = null;
* Console.WriteLine(conn.listMalwares(out malwareList).Message);
*
* }
*/
private static void Test_ListVmApplications(Host host)
{
XenConnect conn = new XenConnect(host, testServerId, testip);
MachineListenerResponse response = null;
conn.getMachineApplicationList("172.16.10.89", 8080, out response);
var serializer = new JavaScriptSerializer();
serializer.MaxJsonLength = Int32.MaxValue;
string serializedResponse = serializer.Serialize(response);
Console.WriteLine(serializedResponse);
}
private void checkbox_existing_Checked(object sender, RoutedEventArgs e)
{
XenConnect conn = new XenConnect(_selectedHost, _settings.SystemIdentifier, _settings.SystemIp);
List <VirtualDisk> isoImages = conn.getVirtualDiskList();
combobox_os_image.Items.Clear();
slider_hd.IsEnabled = false;
textbox_vm_hd.IsEnabled = false;
textblock_slider_value_display.Opacity = 0;
foreach (VirtualDisk disk in isoImages)
{
combobox_os_image.Items.Add(disk.NameCanonical);
}
}
private void btn_file_transfer_send_Click(object sender, RoutedEventArgs e)
{
string filename = textbox_file_transfer_path.Text;
Task.Run(
() =>
{
XenConnect conn = new XenConnect(_CurrentHost, Settings.SystemIdentifier, Settings.SystemIp);
FileStream fs = File.Open(filename, FileMode.Open, FileAccess.Read);
long size = fs.Length;
//TODO: If file length...throw up a message
fs.Close();
conn.transferFile(filename, XenMaster.LibvirtAPI.VirtualMachineBuilder.XEN_PATH_DEFAULT_DISK, size);
Application.Current.Dispatcher.Invoke((Action) delegate {
MessageBox.Show("The file transfer has been completed", "File Transfer", MessageBoxButton.OK, MessageBoxImage.Information);
});
});
}
private void checkbox_existing_Unchecked(object sender, RoutedEventArgs e)
{
//MessageBox.Show(combobox_host.Text);
_selectedHost = getHostByName(combobox_host.Text);
XenConnect conn = new XenConnect(_selectedHost, _settings.SystemIdentifier, _settings.SystemIp);
List <VirtualDisk> isoImages = conn.getISOStorageList();
combobox_os_image.Items.Clear();
foreach (VirtualDisk disk in isoImages)
{
combobox_os_image.Items.Add(disk.NameCanonical);
}
slider_hd.IsEnabled = true;
textbox_vm_hd.IsEnabled = true;
textblock_slider_value_display.Opacity = 100;
}
static void Test_CreateVmExisting2(Host host)
{
//Get vm iso
XenConnect conn = new XenConnect(host, testServerId, testip);
string vmName = "IntrospectionTestBuntu";
int memory = 2000000;
int vcpus = 1;
VirtualMachineBuilder.DomainType domType = VirtualMachineBuilder.DomainType.TRANSIENT;
VirtualMachineBuilder builder = new VirtualMachineBuilder(vmName, "Ubuntu14-04", memory, vcpus, domType);
//builder.setHardDrive(20000, true); //set hard drive size to 20 GB (20k MB)
builder.setHardDriveExisting(true, false, "");
string xml = builder.toXMLString();
conn.createVm(builder);
//string xml = builder.toXMLString();
}
static void Main(string[] args)
{
//info for the remote host we want to connect to
Host host = new Host("172.16.10.115", 29171);
host.Name = "TCC9";
Console.WriteLine("Connecting to Xen Host: " + host.Ip + ":" + host.Port + "...");
XenConnect master = new XenConnect(host, testServerId, testip);
VirtualMachineList vms = master.getHostVirtualMachineList();
Console.WriteLine("Retrieved host details\n\t" + master.getHost().ToString());
Console.WriteLine("Retrieving Virtual Machine List...");
foreach (VM vm in vms.Values)
{
Console.WriteLine("\t" + vm.ToString());
}
Console.WriteLine("Test Complete...");
//Test_ListIso(host);
//Test_CreateVmExisting(host);
//Test_GetVNCPort(host, "4cb12bd0-b1c6-a6bb-d1c4-46246585d351");
//Test_FileTransfer(host, "C:\\Users\\DODTech\\Desktop\\sample.txt", "\\home\\guest_images\\");
//Test_CloneVM(host, "4cb12bd0-b1c6-a6bb-d1c4-46246585d351", "CopyBuntu");
//Test_GetProcessList(host, "Buntu5-1");
//Test_SendProcessListScan(host, "Buntu5-1");
//Test_ListVMStatistics(host, "4cb12bd0-b1c6-a6bb-d1c4-46246585d351");
//Test_ListVmApplications(host);
//Test_StartVmApplication(host);
//Test_ListMalware(host);
//TestMalwareDirectory(host, "\\\\172.16.10.180\\public\\malware");
//Test_SendMalwareTo(host, "172.16.10.89", 3645);
//Test_getVHDStorageList(host);
Test_CreateVmExisting2(host);
//Console.ReadLine();
}
private void updateHostOverview(Host host)
{
label_overview_host_name.Content = host.Name;
label_overview_host_vm_count.Content = host.VmCount;
label_overview_host_power.Content = host.PowerState;
label_overview_host_id.Content = host.Id;
label_overview_host_libvirt_ip.Content = host.LibvirtIp;
label_overview_host_libvirt_port.Content = host.LibvirtPort;
label_overview_host_agentlistner_ip.Content = host.AgentListenerIp;
label_overview_host_agentlistener_port.Content = host.AgentListenerPort;
XenConnect conn = new XenConnect(host, Settings.SystemIdentifier, Settings.SystemIp);
List <DiskStatistic> stats = null;
conn.getHostDiskUsage(out stats);
List <KeyValuePair <string, int> > valueList = new List <KeyValuePair <string, int> >();
foreach (DiskStatistic stat in stats)
{
valueList.Add(new KeyValuePair <string, int>(stat.Filesystem, stat.UsedPercentage));
}
pieChart.DataContext = valueList;
barChart.DataContext = valueList;
}
private void btn_create_vm_Click(object sender, RoutedEventArgs e)
{
XenConnect conn = new XenConnect(_selectedHost, _settings.SystemIdentifier, _settings.SystemIp);
string iso = (string)combobox_os_image.SelectedItem;
string vmName = textbox_vm_name.Text;
int memory = int.Parse(textbox_vm_memory.Text.Replace(",", ""));
int vcpus = int.Parse(textbox_vm_vcpu.Text.Replace(",", ""));
int diskMem = int.Parse(textbox_vm_hd.Text.Replace(",", ""));
VirtualMachineBuilder builder = null;
if (!(bool)checkbox_existing.IsChecked)
{
VirtualMachineBuilder.DomainType domType = VirtualMachineBuilder.DomainType.TRANSIENT;
builder = new VirtualMachineBuilder(vmName, memory * 1000, vcpus, VirtualMachineBuilder.XEN_PATH_DEFAULT_ISO + iso + ".iso", domType);
builder.setHardDrive(diskMem * 1000, true); //set hard drive size to n GB (nk MB)
}
else
{
List <VirtualDisk> disks = conn.getISOStorageList();
string filename = null;
//hard coded for fluff
foreach (VirtualDisk disk in disks)
{
if (disk.NameCanonical.Contains("Ubuntu14"))
{
filename = disk.Name;
break;
}
}
VirtualMachineBuilder.DomainType domType = VirtualMachineBuilder.DomainType.TRANSIENT;
builder = new VirtualMachineBuilder(vmName, memory * 1000, vcpus, VirtualMachineBuilder.XEN_PATH_DEFAULT_ISO + filename, domType);
builder.setHardDriveExisting(true, false, VirtualMachineBuilder.XEN_PATH_DEFAULT_DISK + ((string)combobox_os_image.SelectedItem) + ".img");
conn.createVm(builder);
}
XenError status = conn.createVm(builder);
MessageBoxResult mbr;
if (status.Type == XenError.XenErrorType.SUCCESS)
{
mbr = MessageBox.Show("Succesessfully created virtual machine " + vmName, "Create Virtual Machine", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
mbr = MessageBox.Show(status.Message, "Create Virtual Machine", MessageBoxButton.OK, MessageBoxImage.Information);
}
if (mbr.CompareTo(MessageBoxResult.OK) == 0)
{
if (status.Type == XenError.XenErrorType.SUCCESS)
{
Close();
}
}
}
private void MenuItem_Click(object sender, RoutedEventArgs e)
{
MenuItem item = (MenuItem)sender;
KeyValuePair <string, VM> kvpVM = (KeyValuePair <string, VM>)item.DataContext;
string menuOption = item.Header.ToString();
VM vm = kvpVM.Value;
Host host = SysManager.getVmHost(vm.UUID);
XenConnect conn = new XenConnect(host, Settings.SystemIdentifier, Settings.SystemIp);
switch (menuOption)
{
case "Start":
Task.Run(() => conn.startVm(vm.UUID));
conn.Notifications += e_logXenMasterNotification;
break;
case "Stop":
Task.Run(() => conn.stopVm(vm.UUID));
conn.Notifications += e_logXenMasterNotification;
break;
case "Pause":
Task.Run(() => conn.pauseVm(vm.UUID));
conn.Notifications += e_logXenMasterNotification;
break;
case "Resume":
Task.Run(() => conn.resumeVm(vm.UUID));
conn.Notifications += e_logXenMasterNotification;
break;
case "Force Shutdown":
Task.Run(() => conn.ForceShutdownVm(vm.UUID));
conn.Notifications += e_logXenMasterNotification;
break;
case "Delete":
//Task.Run(() => conn.cloneVm(vm.UUID, "CopyOf" + vm.Name));
//conn.Notifications += e_logXenMasterNotification;
notifyUser("The virtual machine SeniorBuntu has been deleted", "Virtual Machine Deleted", MessageBoxImage.Information);
break;
case "Clone":
Task.Run(() => conn.cloneVm(vm.UUID, "CopyOf" + vm.Name));
conn.Notifications += e_logXenMasterNotification;
break;
case "Remote Control":
Application.Current.Dispatcher.Invoke((Action) delegate {
remoteView(host, vm);
});
break;
case "Info":
VMInfoWindow newHostWin = new VMInfoWindow(vm);
newHostWin.Show();
break;
default:
return;
}
}
static void Test_DeleteVM(Host host, string uuid)
{
XenConnect conn = new XenConnect(host, testServerId, testip);
conn.deleteVm(uuid);
}
static void Test_CloneVM(Host host, string uuid, string name)
{
XenConnect conn = new XenConnect(host, testServerId, testip);
conn.cloneVm(uuid, name);
}
static async void Test_SendProcessListScan(Host host, string VmName)
{
XenConnect conn = new XenConnect(host, testServerId, testip);
await conn.SendProcessListScan("UUID", VmName, 1, ScanTypes.LINUX_PROCESS_LIST_SCAN);
}
/// <summary>
/// Tests List Disks
/// </summary>
/// <param name="host"></param>
static void Test_ListDisks(Host host)
{
Console.WriteLine("Retrieving host virtual machine disks...");
XenConnect con = new XenConnect(host, testServerId, testip);
List <VirtualDisk> disks = con.getVirtualDiskList();
}
private static void Test_getVHDStorageList(Host host)
{
XenConnect conn = new XenConnect(host, testServerId, testip);
List <StorageDisk> disks = conn.getVHDStorageList();
}
