// Alias: Stop-VM public static void StopVm(string ComputerName, string Name, bool PowerOff, PsStreamEventHandlers handlers = null) { Collection <PSObject> res; string Flag = PowerOff ? "-PowerOff" : ""; PSWrapper.Execute(ComputerName, $"Stop-VM -Name \"{Name}\" {Flag} -Force", out res, handlers); }
private void RefreshCollections(WorkerContext ctx = null) { try { if (ctx == null) { databaseManager.FlushCache(); } else { databaseManager.FlushCache(PsStreamEventHandlers.GetUIHandlers(ctx)); ctx.s = StatusCode.OK; } } catch (Exception e) { MessageBox.Show(e.Message, "Exception", MessageBoxButtons.OK); if (ctx != null) { ctx.s = StatusCode.FAILED; } return; } RefreshUI(); }
public static bool PathExists(string host, string path, PsStreamEventHandlers handlers = null) { return((bool)PSWrapper.Execute(host, (ps) => { ps.AddCommand("Test-Path").AddParameter("path", path); return ps.Invoke(); })[0].BaseObject); }
public static void NewDirectory(string host, string path, PsStreamEventHandlers handlers = null) { PSWrapper.Execute(host, (ps) => { return(ps.AddCommand("New-Item") .AddParameter("Type", "Directory") .AddParameter("Path", path) .AddParameter("Force").Invoke()); }, handlers); }
// Alias: Get-VHD public static List <PSObject> GetVhd(string ComputerName, string Path, PsStreamEventHandlers handlers = null) { Collection <PSObject> res; res = PSWrapper.FastExecute(ComputerName, (ps) => { return(ps.AddCommand("Get-VHD").AddParameter("Path", Path).Invoke()); }, handlers); return(res.ToList()); }
// Alias: Get-VM /// <exception cref="Exception">May throw exceptions</exception> public static VirtualMachine GetVm(string hostName, string Name, PsStreamEventHandlers handlers = null) { Collection <PSObject> objs = null; PSWrapper.FastExecute(hostName, $"Get-Vm -Name \"{Name}\"", out objs, handlers); if (objs == null || objs.Count == 0) { return(null); } return(VirtualMachine.FromPSObject(objs[0], hostName)); }
// Alias: Get-VMHost public static PSObject GetVmHost(string ComputerName, PsStreamEventHandlers handlers = null) { Collection <PSObject> res; PSWrapper.Execute(ComputerName, $"Get-VMHost -ComputerName \"{ComputerName}\"", out res, handlers); if (res == null || res.Count <= 0) { return(null); } return(res[0]); }
public static string GetTopMostParent(string hostName, string path, PsStreamEventHandlers handlers = null) { while (true) { var pso = HyperV.GetVhd(hostName, path, handlers)[0]; if (pso == null) { break; } if (string.IsNullOrWhiteSpace((string)pso?.Members["ParentPath"].Value)) { break; } path = (string)pso?.Members["ParentPath"].Value; } return(path); }
// Alias: Get-VM /// <exception cref="Exception">May throw exceptions</exception> public static List <VirtualMachine> GetVm(string hostName, PsStreamEventHandlers handlers = null) { Collection <PSObject> objs = null; PSWrapper.FastExecute(hostName, "Get-Vm", out objs, handlers); if (objs == null || objs.Count == 0) { return(new List <VirtualMachine>()); } List <VirtualMachine> machines = new List <VirtualMachine>(); foreach (var m in objs) { machines.Add(VirtualMachine.FromPSObject(m, hostName)); } return(machines); }
/// <summary> /// Exception safe cache flushing for virtual machines. /// </summary> public void FlushCache(PsStreamEventHandlers handlers = null) { foreach (var e in Directory) { e.Value.BurnChildren(); } Directory.Clear(); var hosts = GetCollection <DbHostComputer>(); var virts = GetCollection <DbVirtualMachine>(); // Loop through each host foreach (var h in hosts.FindAll()) { MasterTreeNode root = null; HostState st = HostState.Unknown; try { Interface.BringOnline(h.HostName); } catch (Exception ex) { MessageBox.Show(ex.Message, "Exception", MessageBoxButtons.OK); st = HostState.Offline; } var vm = new List <VirtualMachine>(); try { vm = HyperV.GetVm(h.HostName, handlers); st = HostState.Online; } catch (Exception ex) { MessageBox.Show(ex.Message, "Exception", MessageBoxButtons.OK); st = HostState.Offline; } root = this.GetRootTreeNode(h, st, vm); // Finally, add this host to our tree if (root != null) { Directory.Add(h.HostName, root); } } }
public InspectDiskDialog(string computer, string path) { InitializeComponent(); var bg = new BackgroundWorkerQueueDialog("Getting information...", ProgressBarStyle.Marquee); bg.AppendTask("Getting information...", DummyWorker.GetWorker((ctx) => { try { pso = HyperV.GetVhd(computer, path, PsStreamEventHandlers.GetUIHandlers(ctx))[0]; ctx.s = StatusCode.OK; } catch (Exception ex) { MessageBox.Show(ex.Message, "Exception", MessageBoxButtons.OK); ctx.s = StatusCode.FAILED; } return(ctx); })); bg.ShowDialog(); this.c = computer; }
private void addbtn_Click(object sender, EventArgs e) { bool isFormValid = false; // Disgusting if (serverComboBox.SelectedIndex == -1) { serverComboBox.IsValid = tribool.FALSE; } else { serverComboBox.IsValid = tribool.TRUE; } if (baseComboBox.SelectedIndex == -1) { baseComboBox.IsValid = tribool.FALSE; } else { baseComboBox.IsValid = tribool.TRUE; } if (configComboBox.SelectedIndex == -1) { configComboBox.IsValid = tribool.FALSE; } else { configComboBox.IsValid = tribool.TRUE; } if (adapterComboBox.SelectedIndex == -1) { adapterComboBox.IsValid = tribool.FALSE; } else { adapterComboBox.IsValid = tribool.TRUE; } if (string.IsNullOrEmpty(vmTextbox.Text)) { vmTextbox.IsValid = tribool.FALSE; } else { vmTextbox.IsValid = tribool.TRUE; } isFormValid = serverComboBox.IsValid == tribool.TRUE && baseComboBox.IsValid == tribool.TRUE && vmTextbox.IsValid == tribool.TRUE && configComboBox.IsValid == tribool.TRUE && adapterComboBox.IsValid == tribool.TRUE; if (!isFormValid) { this.DialogResult = DialogResult.None; } else { // !! IMPORTANT !! // We NEED these exactly here because of cross thread errors // (we cannot get the user inputs from the BackgroundWorker) var a1 = GetSelectedHost().HostName; var a2 = vmTextbox.Text; var a3 = GetSelectedVirtualMachine().Uuid; var a4 = GetSelectedSwitch().Name; var a5 = configComboBox.SelectedIndex; if (a1 != GetSelectedVirtualMachine().Host&& MessageBox.Show( "The selected target server is different from the server hosting the base image. Do you want to continue?", "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No) { this.DialogResult = DialogResult.None; return; } var backgroundWorker = new BackgroundWorkerQueueDialog("Loading servers..."); backgroundWorker.AppendTask("Creating VM...", DummyWorker.GetWorker((ctx) => { // Try to create the VM try { Interface.NewTemplate(a1, a2, a3, a4, jsonHelper.JObject["templates"][a5], PsStreamEventHandlers.GetUIHandlers(ctx)); ctx.s = StatusCode.OK; } catch (Exception ex) { MessageBox.Show(ex.Message, "Exception", MessageBoxButtons.OK); ctx.s = StatusCode.FAILED; } return(ctx); })); backgroundWorker.ShowDialog(); if (backgroundWorker.GetWorker().ReturnedObjects[0].s == StatusCode.OK) { this.DialogResult = DialogResult.OK; } } }
private void AddTemplateDialog_Load(object sender, EventArgs e) { // Get server information BackgroundWorkerQueueDialog backgroundWorker = new BackgroundWorkerQueueDialog("Retrieving Network Information"); foreach (var host in SessionManager.GetDatabase().GetServerDb()) { backgroundWorker.AppendTask("Validating " + host.HostName, NetworkWorkers.GetStarterWorker( new NetworkWorkerObject { HostName = host.HostName } )); backgroundWorker.AppendTask("Getting IP address of " + host.HostName + "...", NetworkWorkers.GetIpWorker()); } backgroundWorker.ShowDialog(); var bw = backgroundWorker.GetWorker(); for (int i = 0; i < SessionManager.GetDatabase().GetServerDb().Count; i++) { if (bw.ReturnedObjects[i * 2 + 1].s == StatusCode.OK) { hostComputers.Add(new HostComputer { HostName = ((NetworkWorkerObject)bw.ReturnedObjects[i * 2 + 1].o).HostName, IpAddress = ((NetworkWorkerObject)bw.ReturnedObjects[i * 2 + 1].o).IpAddress, }); } } // Get configurations for (int i = 0; i < jsonHelper.JObject["templates"]?.Count(); i++) { configComboBox.ComboBox.Items.Add(jsonHelper.JObject["templates"][i]["name"]); } // Add options to host combobox hostComputers.ForEach(x => { if (!string.IsNullOrEmpty(x.HostName) && !string.IsNullOrEmpty(x.IpAddress)) { serverComboBox.ComboBox.Items.Add(x.HostName + " [" + x.IpAddress + "]"); } }); // Get virtual machines backgroundWorker = new BackgroundWorkerQueueDialog("Scanning for Virtual Machines...", ProgressBarStyle.Marquee); backgroundWorker.AppendTask("Getting machines...", DummyWorker.GetWorker((ctx) => { SessionManager.GetDatabase().FlushCache(PsStreamEventHandlers.GetUIHandlers(ctx)); try { foreach (var vm in SessionManager.GetDatabase().GetVm(VirtualMachineType.BASE)) { virtualMachines.Add(vm); } virtualMachines.ForEach(x => { ThreadManager.Invoke(this, baseComboBox, () => baseComboBox.ComboBox.Items.Add(x.Name + " [" + x.Host + "]") ); }); ctx.s = StatusCode.OK; } catch (Exception ex) { MessageBox.Show(ex.Message, "Exception", MessageBoxButtons.OK); ctx.s = StatusCode.FAILED; } return(ctx); })); backgroundWorker.ShowDialog(); }
public ServerPropertyGrid(string hostName) { this.HostName = hostName; // Populate all PSObject psObj = null; new BackgroundWorkerQueueDialog("Getting server information...", ProgressBarStyle.Marquee) .AppendTask("", DummyWorker.GetWorker((ctx) => psObj = HyperV.GetVmHost(hostName, PsStreamEventHandlers.GetUIHandlers(ctx)))) .ShowDialog(); if (psObj == null) { return; } this.VirtualHardDiskPath = (string)psObj.Members["VirtualHardDiskPath"].Value; this.VirtualMachinePath = (string)psObj.Members["VirtualMachinePath"].Value; this.MacAddressMaximum = (string)psObj.Members["MacAddressMaximum"].Value; this.MacAddressMinimum = (string)psObj.Members["MacAddressMinimum"].Value; this.EnableEnhancedSessionMode = (bool)psObj.Members["EnableEnhancedSessionMode"].Value; this.MemoryCapacity = (long)psObj.Members["MemoryCapacity"].Value; this.LogicalProcessorCount = (int)psObj.Members["LogicalProcessorCount"].Value; }
public static void CopyFile(string srcHost, string dstHost, string src, string dst, PsStreamEventHandlers handlers = null) { PSWrapper.Execute(dstHost, (ps) => { ps.AddCommand("Set-Variable").AddParameter("Name", "cred").AddParameter("Value", SessionManager.GetCredential()); ps.AddScript($"Copy-Item \"{src}\" \"{dst}\" -Force –FromSession (New-PSSession –ComputerName {srcHost} -Credential $cred)"); ps.Invoke(); return(null); }, handlers); }
/// <exception cref="Exception">May throw exceptions</exception> public static void RestartService(string hostName, PsStreamEventHandlers handlers = null) { PSWrapper.Execute(hostName, (ps) => ps.AddCommand("Restart-Service").AddParameter("Name", "vmms").Invoke(), handlers); }
public static void NewDeployment(string hostName, string name, Guid tmplUid, string switchName, JToken config, PsStreamEventHandlers handlers = null) { var tmplVm = SessionManager.GetDatabase().GetVm(tmplUid); var baseVm = SessionManager.GetDatabase().GetVm(tmplVm.ParentUuid); if (baseVm == null) { throw new Exception("Template VM without parent."); } var bsrcHost = baseVm.Host; string bdstDir = Path.Combine(Settings.Default.vhdPath, bsrcHost); string bdstPath = Path.Combine(bdstDir, baseVm.Uuid.ToString() + ".vhdx"); string bsrcPath = GetTopMostParent(baseVm.Host, baseVm.VhdPath[0]); var tsrcHost = tmplVm.Host; string tsrcPath = tmplVm.VhdPath[0]; string dstHost = hostName; string vhdPath = Path.Combine(Settings.Default.vhdPath, name + ".vhdx"); if (bsrcHost != hostName) { if (!PathExists(dstHost, bdstPath)) { NewDirectory(dstHost, bdstDir, handlers); CopyFile(bsrcHost, dstHost, bsrcPath, bdstPath, handlers); } } else { bdstPath = bsrcPath; } if (!PathExists(dstHost, vhdPath)) { NewDirectory(dstHost, bdstDir, handlers); CopyFile(tsrcHost, dstHost, tsrcPath, vhdPath, handlers); } HyperV.SetVHD(dstHost, bdstPath, vhdPath, true, handlers); PSWrapper.Execute(dstHost, config, handlers, name, vhdPath, switchName); var vm = HyperV.GetVm(hostName, name, handlers).GetDbObject(); vm.ParentHost = bsrcHost; vm.ParentUuid = baseVm.Uuid; vm.VmType = (int)VirtualMachineType.DEPLOY; SessionManager.GetDatabase().SetVm(vm); }
// Alias: New-VHD public static PSObject NewVHD(string ComputerName, string ParentPath, string Path, PsStreamEventHandlers handlers = null) { return(PSWrapper.Execute(ComputerName, (ps) => { ps.AddStatement().AddScript($"New-VHD -ParentPath \"{ParentPath}\" -Path \"{Path}\" -Differencing"); return ps.Invoke(); }, handlers)[0]); }
private void StopVmms(string host) { SetStatus("Busy."); new BackgroundWorkerQueueDialog("Stopping service...") .AppendTask("Stopping vmms...", DummyWorker.GetWorker((ctx) => Interface.StopService(host, "vmms", PsStreamEventHandlers.GetUIHandlers(ctx)) )).ShowDialog(); Thread.Sleep(1000); SetStatus("Ready."); }
private void startToolButton_Click(object sender, EventArgs e) { var node = treeListView.SelectedObject as MasterTreeNode; if (node == null) { return; } BackgroundWorkerQueueDialog bg = new BackgroundWorkerQueueDialog("Setting machine state..."); if (node.State?.vs == VirtualMachineState.Paused) { bg.AppendTask("", DummyWorker.GetWorker((ctx) => HyperV.ResumeVm(node.Host, node.Name, PsStreamEventHandlers.GetUIHandlers(ctx)))); } else { bg.AppendTask("", DummyWorker.GetWorker((ctx) => HyperV.StartVm(node.Host, node.Name, PsStreamEventHandlers.GetUIHandlers(ctx)))); } bg.ShowDialog(); RefreshBackground(); }
// Alias: Remove-VMSnapshot public static void RemoveVmSnapshot(string ComputerName, string VMName, string Name, PsStreamEventHandlers handlers = null) { Collection <PSObject> res; PSWrapper.Execute(ComputerName, $"Remove-VMSnapshot -Name \"{Name}\" -VMName \"{VMName}\" -IncludeAllChildSnapshots -Confirm:$false", out res, handlers); }
// Alias: Checkpoint-VM public static void CheckpointVm(string ComputerName, string VMName, string Name, PsStreamEventHandlers handlers = null) { Collection <PSObject> res; PSWrapper.Execute(ComputerName, $"Checkpoint-VM -SnapshotName \"{Name}\" -Name \"{VMName}\" -Confirm:$false", out res, handlers); }
// Alias: Set-VHD public static void SetVHD(string ComputerName, string ParentPath, string Path, bool IgnoreMismatchId, PsStreamEventHandlers handlers = null) { PSWrapper.Execute(ComputerName, (ps) => { string Flag = /*IgnoreMismatchId ? "-IgnoreMismatchId" :*/ ""; ps.AddStatement().AddScript($"Set-VHD -Path \"{Path}\" -ParentPath \"{ParentPath}\" {Flag}"); return(ps.Invoke()); }, handlers); }
public static void StartService(string host, string svc, PsStreamEventHandlers handlers = null) { Collection <PSObject> res = null; PSWrapper.Execute(host, $"net start \"{svc}\" | Write-Verbose -Verbose", out res, handlers); }
public static void NewTemplate(string hostName, string name, Guid baseUid, string switchName, JToken config, PsStreamEventHandlers handlers = null) { var baseVm = SessionManager.GetDatabase().GetVm(baseUid); var srcHost = baseVm.Host; var dstHost = hostName; string dstDir = Path.Combine(Settings.Default.vhdPath, srcHost); string srcPath = GetTopMostParent(baseVm.Host, baseVm.VhdPath[0]); string dstPath = Path.Combine(dstDir, baseUid.ToString() + ".vhdx"); string vhdPath = Path.Combine(Settings.Default.vhdPath, name + ".vhdx"); if (srcHost != hostName) { if (!PathExists(dstHost, dstPath)) { NewDirectory(dstHost, dstDir, handlers); CopyFile(srcHost, dstHost, srcPath, dstPath, handlers); } } else { dstPath = srcPath; } HyperV.NewVHD(dstHost, dstPath, vhdPath, handlers); PSWrapper.Execute(dstHost, config, handlers, name, vhdPath, switchName); var vm = HyperV.GetVm(hostName, name, handlers).GetDbObject(); vm.ParentHost = srcHost; vm.ParentUuid = baseUid; vm.VmType = (int)VirtualMachineType.TEMPLATE; SessionManager.GetDatabase().SetVm(vm); }
private void suspendToolButton_Click(object sender, EventArgs e) { var node = treeListView.SelectedObject as MasterTreeNode; if (node == null) { return; } new BackgroundWorkerQueueDialog("Setting machine state...") .AppendTask("", DummyWorker.GetWorker((ctx) => HyperV.SuspendVm(node.Host, node.Name, PsStreamEventHandlers.GetUIHandlers(ctx)) )).ShowDialog(); RefreshBackground(); }
// Alias: Save-VM public static void SaveVm(string ComputerName, string Name, PsStreamEventHandlers handlers = null) { Collection <PSObject> res; PSWrapper.Execute(ComputerName, $"Save-VM -Name \"{Name}\"", out res, handlers); }