/////该函数是为了windows服务和桌面交互
private void serviceInstaller1_AfterInstall(object sender, InstallEventArgs e)
{
base.OnAfterInstall(e.SavedState);
ManagementObject wmiService = null;
ManagementBaseObject InParam = null;
try
{
wmiService = new ManagementObject(string.Format("Win32_Service.Name='{0}'", serviceInstaller1.ServiceName));
InParam = wmiService.GetMethodParameters("Change");
InParam["DesktopInteract"] = true;
wmiService.InvokeMethod("Change", InParam, null);
}
finally
{
if (InParam != null)
{
InParam.Dispose();
}
if (wmiService != null)
{
wmiService.Dispose();
}
}
}
public static ManagementBaseObject GetSummaryInformation(VM vm, UInt32[] requestedInformation)
{
ManagementScope scope = new ManagementScope(@"\\" + vm.Host.Name + @"\root\virtualization", vm.Host.HostConnectionOptions);
ManagementObject vmObj = vm.Instance;//GetTargetComputer(vm.GUID, scope);
ManagementObject[] virtualSystemSettings = new ManagementObject[] { Utility.GetVirtualSystemSettingData(vmObj) };
ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemManagementService");
ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("GetSummaryInformation");
string[] settingPathes = new string[virtualSystemSettings.Length];
for (int i = 0; i < settingPathes.Length; ++i)
{
settingPathes[i] = virtualSystemSettings[i].Path.Path;
}
inParams["SettingData"] = settingPathes;
inParams["RequestedInformation"] = requestedInformation;
ManagementBaseObject outParams = virtualSystemService.InvokeMethod("GetSummaryInformation", inParams, null);
if ((UInt32)outParams["ReturnValue"] == ReturnCode.Completed)
{
ManagementBaseObject[] summaryInformationArray = (ManagementBaseObject[])outParams["SummaryInformation"];
return(summaryInformationArray[0]);
}
else
{
MessageBox.Show("Failed to retrieve virtual system summary information", "Error!", MessageBoxButton.OK, MessageBoxImage.Error);
}
inParams.Dispose();
outParams.Dispose();
return(null);
}
public static bool IsEMSEnabled()
{
bool isEMSEnabled = false;
try
{
// {9dea862c-5cdd-4e70-acc1-f32b344d4795} is the GUID of the System BcdStore
ManagementObject scopeObj = new ManagementObject(new ManagementScope(@"root\WMI"), new ManagementPath("root\\WMI:BcdObject.Id=\"{9dea862c-5cdd-4e70-acc1-f32b344d4795}\",StoreFilePath=\"\""), null);
ManagementBaseObject elementObj = null;
elementObj = scopeObj.GetMethodParameters("GetElement");
// Get the list of IDs from 0x24000001, which is a BCD constant: BcdBootMgrObjectList_DisplayOrder
elementObj["Type"] = ((UInt32)0x24000001);
ManagementBaseObject BCDObj = scopeObj.InvokeMethod("GetElement", elementObj, null);
ManagementBaseObject value = ((ManagementBaseObject)(BCDObj.Properties["Element"].Value));
// Get list of Ids
string[] idList = (string[])value.GetPropertyValue("Ids");
// Define the Management object used to access the WMI info from BCD store
scopeObj = new ManagementObject(new ManagementScope(@"root\WMI"), new ManagementPath("root\\WMI:BcdObject.Id=\"" + idList[0] + "\",StoreFilePath=\"\""), null);
elementObj = scopeObj.GetMethodParameters("GetElement");
// BcdOSLoaderBoolean_EmsEnabled (0x260000b0)
// The EMS enabled setting. The element data format is BcdBooleanElement.
elementObj["Type"] = ((UInt32)0x260000b0);
BCDObj = scopeObj.InvokeMethod("GetElement", elementObj, null);
value = ((ManagementBaseObject)(BCDObj.Properties["Element"].Value));
// try get EMS enabled setting
Boolean.TryParse(value.GetPropertyValue("boolean").ToString(), out isEMSEnabled);
// Dispose unmanaged objects
if (scopeObj != null)
{
scopeObj.Dispose();
}
if (elementObj != null)
{
elementObj.Dispose();
}
if (BCDObj != null)
{
BCDObj.Dispose();
}
if (value != null)
{
value.Dispose();
}
}
catch (Exception e)
{
Tracer.WriteError(String.Format("Exception {0} Trace {1}", e.Message, e.StackTrace));
}
return(isEMSEnabled);
}
public static VMJob RequestStateChange(VM vm, int state)
{
ManagementScope scope = new ManagementScope(@"\\" + vm.Host.Name + @"\root\virtualization", vm.Host.HostConnectionOptions);
ManagementObject vmObj = vm.Instance;//Utility.GetTargetComputer(vm.GUID, scope);
ManagementBaseObject inParams = vmObj.GetMethodParameters("RequestStateChange");
inParams["RequestedState"] = state;
ManagementBaseObject outParams = vmObj.InvokeMethod("RequestStateChange", inParams, null);
UInt32 returnValue = (UInt32)outParams["ReturnValue"];
string jobPath = (string)outParams["Job"];
VMJob ThisJob = null;
if (jobPath != null)
{
ThisJob = new VMJob(new ManagementObject(scope, new ManagementPath(jobPath), null));
}
inParams.Dispose();
outParams.Dispose();
vmObj.Dispose();
if ((jobPath == null) && (returnValue != ReturnCode.Completed) && (returnValue != ReturnCode.Started))
{
throw new VMStateChangeException(returnValue);
}
//JobCompleted(outParams, scope, out ErrorCode);
return(ThisJob);
}
private void DesktopInteract()
{
ManagementObject wmiService = null;
ManagementBaseObject InParam = null;
string ServiceName = "usbalertSidd";
try
{
wmiService = new ManagementObject(string.Format("Win32_Service.Name='{0}'",
ServiceName));
InParam = wmiService.GetMethodParameters("Change");
InParam["DesktopInteract"] = true;
wmiService.InvokeMethod("Change", InParam, null);
}
finally
{
if (InParam != null)
{
InParam.Dispose();
}
if (wmiService != null)
{
wmiService.Dispose();
}
}
}
/// <summary>
/// Deletes the share.
/// </summary>
public void DeleteShare()
{
ManagementBaseObject outParams = null;
ManagementObject shareInstance = null;
try
{
shareInstance = new ManagementObject(@"root\cimv2:Win32_Share.Name='" + this.shareName + "'");
outParams = shareInstance.InvokeMethod("Delete", null, null);
if ((uint)outParams["ReturnValue"] != 0)
{
throw new WindowsShareException("Unable to delete share. Win32_Share.Delete Error Code: " + outParams["ReturnValue"]);
}
}
catch (Exception ex)
{
throw new WindowsShareException("Unable to delete share: " + this.shareName, ex);
}
finally
{
if (shareInstance != null)
{
shareInstance.Dispose();
}
if (outParams != null)
{
outParams.Dispose();
}
}
}
protected override void OnAfterInstall(IDictionary savedState)
{
//允许服务与桌面交互
base.OnAfterInstall(savedState);
ManagementObject wmiService = null;
ManagementBaseObject InParam = null;
try
{
wmiService = new ManagementObject(string.Format("Win32_Service.Name='{0}'", SwitchServices.ServiceName));
InParam = wmiService.GetMethodParameters("Change");
InParam["DesktopInteract"] = true;
wmiService.InvokeMethod("Change", InParam, null);
}
finally
{
if (InParam != null)
{
InParam.Dispose();
}
if (wmiService != null)
{
wmiService.Dispose();
}
}
}
/// <summary>
/// Creates the share.
/// </summary>
/// <param name="shareName">Name of the share.</param>
/// <param name="folderPath">The folder path.</param>
/// <returns>WindwsShare instance.</returns>
public static WindowsShare CreateShare(string shareName, string folderPath)
{
ManagementClass shareClass = null;
ManagementClass sd = null;
ManagementBaseObject inParams = null;
ManagementBaseObject outParams = null;
try
{
sd = new ManagementClass(new ManagementPath("Win32_SecurityDescriptor"), null);
sd["ControlFlags"] = 0x4;
sd["DACL"] = new ManagementBaseObject[] { };
shareClass = new ManagementClass("Win32_Share");
inParams = shareClass.GetMethodParameters("Create");
inParams["Name"] = shareName;
inParams["Path"] = new DirectoryInfo(folderPath).FullName;
//// inParams["Description"] = description;
inParams["Type"] = 0x0; // Type of Disk Drive
inParams["Access"] = sd;
outParams = shareClass.InvokeMethod("Create", inParams, null);
if ((uint)outParams["ReturnValue"] != 0)
{
throw new WindowsShareException("Unable to create share. Win32_Share.Create Error Code: " + outParams["ReturnValue"]);
}
}
catch (Exception ex)
{
throw new WindowsShareException("Unable to create share", ex);
}
finally
{
if (shareClass != null)
{
shareClass.Dispose();
}
if (inParams != null)
{
inParams.Dispose();
}
if (outParams != null)
{
outParams.Dispose();
}
if (sd != null)
{
sd.Dispose();
}
}
return(new WindowsShare(shareName));
}
public void Dispose()
{
if (IsSupported)
{
m_brightnessClass?.Dispose();
m_brightnessInstance?.Dispose();
}
}
public void Dispose(ref ManagementBaseObject x)
{
if (x != null)
{
x.Dispose();
x = null;
}
}
private static bool ValidateInternal(string userInfo, string licenseValue)
{
try {
RegistryKey regKey = null;
ManagementObjectSearcher searcher = null;
ManagementBaseObject obj = null;
try {
string machineGuid = string.Empty;
regKey = Registry.LocalMachine.OpenSubKey("Software").OpenSubKey("Microsoft").OpenSubKey("Cryptography");
machineGuid = Convert.ToString(regKey.GetValue("MachineGuid"));
searcher = new ManagementObjectSearcher("SELECT * FROM Win32_UserAccount");
obj = searcher.Get().Cast <ManagementBaseObject>().First();
string administratorSID = Convert.ToString(obj["SID"]);
searcher = new ManagementObjectSearcher("SELECT * FROM Win32_OperatingSystem");
obj = searcher.Get().Cast <ManagementBaseObject>().First();
string OSSerialNumber = Convert.ToString(obj["SerialNumber"]);
string OSRegisteredUser = Convert.ToString(obj["RegisteredUser"]);
string OSVersion = Convert.ToString(obj["Version"]);
string OSInstalDate = Convert.ToString(obj["InstallDate"]);
searcher = new ManagementObjectSearcher("SELECT * FROM Win32_BaseBoard");
obj = searcher.Get().Cast <ManagementBaseObject>().First();
string boardManufacturer = Convert.ToString(obj["Manufacturer"]);
string boardProduct = Convert.ToString(obj["Product"]);
string value = string.Format("{0};AdministratorSID={1};MachineGuid={2};OSSerialNumber={3};OSRegisteredUser={4};OSVersion={5};OSInstallDate={6};BoardManufacturer={7};BoardProduct={8}",
userInfo,
administratorSID, machineGuid, OSSerialNumber, OSRegisteredUser, OSVersion, OSInstalDate, boardManufacturer, boardProduct);
if (licenseValue == value)
{
return(true);
}
} catch {
throw;
} finally {
if (regKey != null)
{
try {
regKey.Close();
} catch { }
}
if (searcher != null)
{
try {
searcher.Dispose();
} catch { }
}
if (obj != null)
{
try {
obj.Dispose();
} catch { }
}
}
return(false);
} catch {
throw;
}
}
void IDisposable.Dispose()
{
GC.SuppressFinalize(this);
if (_managementObject == null)
{
return;
}
_managementObject.Dispose();
_managementObject = null;
}
/// <summary>
/// Get a Dictionary representation of a ManagementBaseObject object
/// </summary>
/// <param name="obj">The object to convert.</param>
private static Dictionary <string, object> ManagementObjectToDictionary(ManagementBaseObject obj)
{
try
{
return(obj.Properties.Cast <PropertyData>().ToDictionary(property => property.Name, property =>
property.Value is ManagementBaseObject ? ManagementObjectToDictionary(property.Value as ManagementBaseObject) as object : property.Value.ToString()));
}
finally
{
obj.Dispose();
}
}
public string CreateVirtualSystemSnapshot(string vmName, vm_control vmctrl)
{
ManagementBaseObject result = null;
string ret = "";
const string Job = "Job";
const string JobState = "JobState";
if (scope == null)
{
scope = getRemoteScope();
}
ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemManagementService");
ManagementObject vm = Utility.GetTargetComputer(vmName, scope);
ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("CreateVirtualSystemSnapshot");
inParams["SourceSystem"] = vm.Path.Path;
ManagementBaseObject outParams = virtualSystemService.InvokeMethod("CreateVirtualSystemSnapshot", inParams, null);
if (Utility.JobCompleted(outParams, scope, vmctrl))
{
if ((UInt32)outParams["ReturnValue"] == ReturnCode.Started)
{
if (Utility.JobCompleted(outParams, scope, null))
{
ret = ("Snapshot was created successfully.");
}
else
{
ret = ("Failed to create snapshot VM");
}
}
else if ((UInt32)outParams["ReturnValue"] == ReturnCode.Completed)
{
ret = ("Snapshot was created successfully.");
}
else
{
ret = String.Format("Create virtual system snapshot failed with error {0}", outParams["ReturnValue"].ToString());
}
}
inParams.Dispose();
outParams.Dispose();
vm.Dispose();
virtualSystemService.Dispose();
return(ret);
}
/// <summary>
/// Workaround to dispose ManagementBaseObject properly.
/// See http://stackoverflow.com/questions/11896282
/// </summary>
/// <param name="disposable"></param>
public static void DisposeOne(IDisposable disposable)
{
ManagementBaseObject mbo = disposable as ManagementBaseObject;
if (mbo != null)
{
mbo.Dispose();
}
else
{
disposable.Dispose();
}
}
/*
* public void SetSharePermissions()
* {
* }
*/
/// <summary>
/// Gets the share permissions.
/// </summary>
/// <returns>The Names of the Trustees.</returns>
public string[] GetSharePermissions()
{
ManagementObject win32LogicalSecuritySetting = null;
ManagementBaseObject getSecurityDescriptorReturn = null;
ManagementBaseObject securityDescriptor = null;
try
{
win32LogicalSecuritySetting = new ManagementObject(@"root\cimv2:Win32_LogicalShareSecuritySetting.Name='" + this.shareName + "'");
getSecurityDescriptorReturn = win32LogicalSecuritySetting.InvokeMethod("GetSecurityDescriptor", null, null);
if ((uint)getSecurityDescriptorReturn["ReturnValue"] != 0)
{
throw new WindowsShareException("Unable to get share permissions. Error Code: " + getSecurityDescriptorReturn["ReturnValue"]);
}
securityDescriptor = getSecurityDescriptorReturn["Descriptor"] as ManagementBaseObject;
ManagementBaseObject[] dacl = securityDescriptor["DACL"] as ManagementBaseObject[];
if (dacl == null)
{
return(new string[] { });
}
else
{
return(dacl.Select(ac => ((ac["Trustee"] as ManagementBaseObject)["Name"] as string)).ToArray());
}
}
catch (Exception ex)
{
throw new WindowsShareException("Unable to get share permissions", ex);
}
finally
{
if (win32LogicalSecuritySetting != null)
{
win32LogicalSecuritySetting.Dispose();
}
if (getSecurityDescriptorReturn != null)
{
getSecurityDescriptorReturn.Dispose();
}
if (securityDescriptor != null)
{
securityDescriptor.Dispose();
}
}
}
public void CreateSnapshot()
{
ManagementScope scope = AsRawMachine.Scope;
ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemSnapshotService");
ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("CreateSnapshot");
// Set the AffectedSystem property.
ManagementObject vm = Utility.GetTargetComputer(Name, scope);
if (null == vm)
{
throw new ArgumentException(string.Format("The virtual machine \"{0}\" could not be found.", Name));
}
inParams["AffectedSystem"] = vm.Path.Path;
inParams["SnapshotSettings"] = "";
// Set the SnapshotType property.
inParams["SnapshotType"] = 2; // Full snapshot.
ManagementBaseObject outParams = virtualSystemService.InvokeMethod("CreateSnapshot", inParams, null);
if ((UInt32)outParams["ReturnValue"] == ReturnCode.Started)
{
if (Utility.JobCompleted(outParams, scope))
{
Console.WriteLine("Snapshot was created successfully.");
}
else
{
Console.WriteLine("Failed to create snapshot VM");
}
}
else if ((UInt32)outParams["ReturnValue"] == ReturnCode.Completed)
{
Console.WriteLine("Snapshot was created successfully.");
}
else
{
Console.WriteLine("Create virtual system snapshot failed with error {0}", outParams["ReturnValue"]);
}
inParams.Dispose();
outParams.Dispose();
vm.Dispose();
virtualSystemService.Dispose();
}
public IEnumerable <IResourceAllocationSettingData> AddResourceSettings(IVirtualSystemSettingData affectedConfiguration, string[] resourceSettings)
{
ManagementBaseObject inParams = this._Instance.GetMethodParameters(nameof(AddResourceSettings));
try
{
inParams["AffectedConfiguration"] = (object)affectedConfiguration.Object.Path.Path;
inParams["ResourceSettings"] = (object)resourceSettings;
ManagementBaseObject result = this._Instance.InvokeAndWait(nameof(AddResourceSettings), inParams);
try
{
if (result["ResultingResourceSettings"] != null)
{
string[] strArray = (string[])result["ResultingResourceSettings"];
for (int index = 0; index < strArray.Length; ++index)
{
yield return(ResourceAllocationSettingData.CreateFromPath(strArray[index], this.Scope));
}
strArray = (string[])null;
}
else if (result["Job"] != null)
{
foreach (ManagementObject o in ((ManagementObject)result["Job"]).GetRelated((string)null, "Msvm_AffectedJobElement", (string)null, (string)null, (string)null, (string)null, false, (EnumerationOptions)null))
{
yield return(ResourceAllocationSettingData.CreateFromObject(o));
}
}
}
finally
{
if (result != null)
{
result.Dispose();
}
}
result = (ManagementBaseObject)null;
}
finally
{
if (inParams != null)
{
inParams.Dispose();
}
}
inParams = (ManagementBaseObject)null;
}
public IEnumerable <IEthernetSwitchFeatureSettingData> ModifyFeatureSettings(string[] featureSettings)
{
ManagementBaseObject inParams = this._Instance.GetMethodParameters(nameof(ModifyFeatureSettings));
try
{
inParams["FeatureSettings"] = (object)featureSettings;
ManagementBaseObject result = this._Instance.InvokeAndWait(nameof(ModifyFeatureSettings), inParams);
try
{
if (result["ResultingFeatureSettings"] != null)
{
string[] strArray = (string[])result["ResultingFeatureSettings"];
for (int index = 0; index < strArray.Length; ++index)
{
yield return(EthernetSwitchFeatureSettingData.CreateFromPath(strArray[index]));
}
strArray = (string[])null;
}
else if (result["Job"] != null)
{
foreach (ManagementObject o in ((ManagementObject)result["Job"]).GetRelated((string)null, "Msvm_AffectedJobElement", (string)null, (string)null, (string)null, (string)null, false, (EnumerationOptions)null))
{
yield return(EthernetSwitchFeatureSettingData.CreateFromObject(o));
}
}
}
finally
{
if (result != null)
{
result.Dispose();
}
}
result = (ManagementBaseObject)null;
}
finally
{
if (inParams != null)
{
inParams.Dispose();
}
}
inParams = (ManagementBaseObject)null;
}
/// <summary>
/// Reverts the VM to the previous shapshop
/// </summary>
/// <param name="vm">The vm to apply the snapstop to</param>
/// <param name="snapshot">The snapshot image</param>
/// <returns>True of operation completed without error</returns>
private bool ApplyVirtualSystemSnapshot(ManagementObject vm, ManagementObject snapshot)
{
var jobSuccesful = false;
ManagementScope scope = vm.Scope;
ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemManagementService");
ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("ApplyVirtualSystemSnapshot");
inParams["SnapshotSettingData"] = snapshot.Path.Path;
inParams["ComputerSystem"] = vm.Path.Path;
ManagementBaseObject outParams = virtualSystemService.InvokeMethod("ApplyVirtualSystemSnapshot", inParams, null);
if ((uint)outParams["ReturnValue"] == ReturnCode.Started)
{
if (Utility.JobCompleted(outParams, scope))
{
this.LogBuildMessage(string.Format(CultureInfo.InvariantCulture, "Snapshot of [{0}] was applied successfully.", this.VMName.Get(this.ActivityContext)));
jobSuccesful = true;
}
else
{
this.LogBuildWarning(string.Format(CultureInfo.InvariantCulture, "Failed to apply snapshot for VM [{0}].", this.VMName.Get(this.ActivityContext)));
}
}
else if ((uint)outParams["ReturnValue"] == ReturnCode.Completed)
{
this.LogBuildMessage(string.Format(CultureInfo.InvariantCulture, "Snapshot of [{0}] was applied successfully.", this.VMName.Get(this.ActivityContext)));
jobSuccesful = true;
}
else
{
this.LogBuildWarning(string.Format(CultureInfo.InvariantCulture, "Snapshot of [{0}] was applied but returned error {1}", this.VMName.Get(this.ActivityContext), outParams["ReturnValue"]));
}
inParams.Dispose();
outParams.Dispose();
snapshot.Dispose();
vm.Dispose();
virtualSystemService.Dispose();
return(jobSuccesful);
}
public static bool setIpWMI(string guid, string IpAddress, string SubnetMask)
{
try
{
var mo = getWMI(guid);
ManagementBaseObject newIP = mo.GetMethodParameters("EnableStatic");
newIP["IPAddress"] = new string[] { IpAddress };
newIP["SubnetMask"] = new string[] { SubnetMask };
ManagementBaseObject setIP = mo.InvokeMethod("EnableStatic", newIP, null);
setIP.Dispose();
return(true);
}
catch (Exception e)
{
Trace.TraceInformation("Internet Sharing Unable to set up IP:" + e.Message);
}
return(false);
}
public static VMJob SetVMResource(VM vm, ManagementObject resource, Dictionary <string, object> Params)
{
ManagementScope scope = new ManagementScope(@"\\" + vm.Host.Name + @"\root\virtualization", vm.Host.HostConnectionOptions);
ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemManagementService");
ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("ModifyVirtualSystemResources");
ManagementObject vmObj = vm.Instance;
//ManagementObject resource = GetMemory(vm);
//memSettings["Limit"] = quantity;
//memSettings["Reservation"] = quantity;
foreach (string key in Params.Keys)
{
resource[key] = Params[key];
}
//resource["VirtualQuantity"] = quantity;
string[] Resources = new string[1];
Resources[0] = resource.GetText(TextFormat.CimDtd20);
//ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("ModifyVirtualSystemResources");
inParams["ComputerSystem"] = vmObj.Path.Path;
inParams["ResourcesettingData"] = Resources;
VMJob ThisJob = null;
ManagementBaseObject outParams = virtualSystemService.InvokeMethod("ModifyVirtualSystemResources", inParams, null);
//MessageBox.Show(outParams.GetText(TextFormat.Mof));
string jobPath = (string)outParams["Job"];
UInt32 returnValue = (UInt32)outParams["ReturnValue"];
if (jobPath != null)
{
ManagementObject jobObj = new ManagementObject(scope, new ManagementPath(jobPath), null);
ThisJob = new VMJob(jobObj);
}
inParams.Dispose();
//resource.Dispose();
outParams.Dispose();
vmObj.Dispose();
virtualSystemService.Dispose();
if ((jobPath == null) && (returnValue != ReturnCode.Completed) && (returnValue != ReturnCode.Started))
{
throw new VMResourcesUpdateException(returnValue);
}
return(ThisJob);
}
public void ApplySnapshot(ManagementObject snapshot)
{
ManagementScope scope = AsRawMachine.Scope;
ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemSnapshotService");
ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("ApplySnapshot");
ManagementObject vm = Utility.GetTargetComputer(Name, scope);
if (null == vm)
{
throw new ArgumentException(string.Format("The virtual machine \"{0}\" could not be found.", Name));
}
inParams["Snapshot"] = snapshot;
ManagementBaseObject outParams = virtualSystemService.InvokeMethod("ApplySnapshot", inParams, null);
if ((UInt32)outParams["ReturnValue"] == ReturnCode.Started)
{
if (Utility.JobCompleted(outParams, scope))
{
Console.WriteLine("Snapshot was applied successfully.");
}
else
{
Console.WriteLine("Failed to apply snapshot");
}
}
else if ((UInt32)outParams["ReturnValue"] == ReturnCode.Completed)
{
Console.WriteLine("Snapshot was applied successfully.");
}
else
{
Console.WriteLine("Apply virtual system snapshot failed with error {0}", outParams["ReturnValue"]);
}
inParams.Dispose();
outParams.Dispose();
vm.Dispose();
virtualSystemService.Dispose();
}
public static VMJob RemoveVirtualSystemSnapshotTree(VM vm, VMSnapshot snapshot)
{
ManagementScope scope = new ManagementScope(@"\\" + vm.Host.Name + @"\root\virtualization", vm.Host.HostConnectionOptions);
ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemManagementService");
ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("RemoveVirtualSystemSnapshotTree");
ManagementObject vmObj = Utility.GetTargetComputer(vm.GUID, scope);
ManagementObject vmSnapshotObj = snapshot.SnapshotInstance;
inParams["SnapshotSettingData"] = vmSnapshotObj.Path.Path;
ManagementBaseObject outParams = virtualSystemService.InvokeMethod("RemoveVirtualSystemSnapshotTree", inParams, null);
VMJob ThisJob = new VMJob(new ManagementObject(scope, new ManagementPath((string)outParams["Job"]), null));
inParams.Dispose();
outParams.Dispose();
vmSnapshotObj.Dispose();
vmObj.Dispose();
virtualSystemService.Dispose();
return(ThisJob);
}
/// <summary>
/// Creates a new snapshot of the named VM
/// </summary>
/// <returns>True if completed without error</returns>
private bool CreateVirtualSystemSnapshot()
{
// based on http://msdn.microsoft.com/en-us/library/cc723875(v=VS.85).aspx
var jobSuccesful = false;
ManagementScope scope = this.GetScope();
ManagementObject vm = GetVm(scope, this.VMName.Get(this.ActivityContext));
ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemManagementService");
ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("CreateVirtualSystemSnapshot");
inParams["SourceSystem"] = vm.Path.Path;
ManagementBaseObject outParams = virtualSystemService.InvokeMethod("CreateVirtualSystemSnapshot", inParams, null);
if ((uint)outParams["ReturnValue"] == ReturnCode.Started)
{
if (Utility.JobCompleted(outParams, scope))
{
this.LogBuildMessage(string.Format(CultureInfo.InvariantCulture, "Snapshot of [{0}] was taken successfully.", this.VMName.Get(this.ActivityContext)));
jobSuccesful = true;
}
else
{
this.LogBuildWarning(string.Format(CultureInfo.InvariantCulture, "Failed to create snapshot for VM [{0}].", this.VMName.Get(this.ActivityContext)));
}
}
else if ((uint)outParams["ReturnValue"] == ReturnCode.Completed)
{
this.LogBuildMessage(string.Format(CultureInfo.InvariantCulture, "Snapshot of [{0}] was taken successfully.", this.VMName.Get(this.ActivityContext)));
jobSuccesful = true;
}
else
{
this.LogBuildWarning(string.Format(CultureInfo.InvariantCulture, "Failed to create snapshot for VM [{0}]. with error {1}", this.VMName.Get(this.ActivityContext), outParams["ReturnValue"]));
}
inParams.Dispose();
outParams.Dispose();
vm.Dispose();
virtualSystemService.Dispose();
return(jobSuccesful);
}
private void serviceInstaller_Committing(object sender, InstallEventArgs e)
{
ManagementBaseObject InParam = null;
ManagementBaseObject OutParam = null;
try
{
// Windows Interact W/Desktop...
ConnectionOptions coOptions = new ConnectionOptions();
coOptions.Impersonation = ImpersonationLevel.Impersonate;
ManagementScope mgmtScope = new System.Management.ManagementScope(@"root\CIMV2", coOptions);
mgmtScope.Connect();
using (ManagementObject wmiService = new ManagementObject(string.Format(Properties.Resources.Win32ServiceName, serviceInstaller.ServiceName)))
{
InParam = wmiService.GetMethodParameters(Properties.Resources.ParamInfo);
InParam[Properties.Resources.DesktopInteract] = true;
OutParam = wmiService.InvokeMethod(Properties.Resources.ParamInfo, InParam, null);
}
// set actions on recovery in order to restart the service 3 times
var fa = new List <FailureAction>();
fa.Add(new FailureAction(RecoverAction.Restart, 2000));
fa.Add(new FailureAction(RecoverAction.Restart, 2000));
fa.Add(new FailureAction(RecoverAction.Restart, 2000));
SetRestartOnFailureRecovery(fa, "", "");
}
catch (Exception Error)
{
EventLog.WriteEntry(serviceInstaller.ServiceName, Error.ToString(), EventLogEntryType.Error);
}
finally
{
if (InParam != null)
{
InParam.Dispose();
}
if (OutParam != null)
{
OutParam.Dispose();
}
}
}
public static string GetDiskSerialNumber()
{
ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher();
managementObjectSearcher.Query = new SelectQuery("Win32_DiskDrive", "", new string[]
{
"PNPDeviceID",
"Signature"
});
ManagementObjectCollection managementObjectCollection = managementObjectSearcher.Get();
ManagementObjectCollection.ManagementObjectEnumerator enumerator = managementObjectCollection.GetEnumerator();
enumerator.MoveNext();
ManagementBaseObject current = enumerator.Current;
string result = current.Properties["signature"].Value.ToString().Trim();
current.Dispose();
managementObjectSearcher.Dispose();
return(result);
}
public static VMJob CreateVirtualSystemSnapshot(VM vm)
{
ManagementScope scope = new ManagementScope(@"\\" + vm.Host.Name + @"\root\virtualization", vm.Host.HostConnectionOptions);
ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemManagementService");
ManagementObject vmObj = Utility.GetTargetComputer(vm.GUID, scope);
ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("CreateVirtualSystemSnapshot");
inParams["SourceSystem"] = vmObj.Path.Path;
ManagementBaseObject outParams = virtualSystemService.InvokeMethod("CreateVirtualSystemSnapshot", inParams, null);
//UInt32 returnValue = (UInt32)outParams["ReturnValue"];
VMJob ThisJob = new VMJob(new ManagementObject(scope, new ManagementPath((string)outParams["Job"]), null));
inParams.Dispose();
outParams.Dispose();
vmObj.Dispose();
virtualSystemService.Dispose();
return(ThisJob);
}
public async Task <bool> RebootComputerAsync(string ComputerName, string AdminUser, string AdminPassword, string UserDomain, string UserDNSDomain)
{
var ManagementPath = new ManagementPath(String.Format(@"\\{0}.{1}\root\cimv2", ComputerName, UserDNSDomain));
var Options = new ConnectionOptions()
{
EnablePrivileges = true,
Username = AdminUser,
Password = AdminPassword,
Authority = "ntlmdomain:" + UserDomain,
Timeout = new TimeSpan(0, 0, 5),
Authentication = AuthenticationLevel.Default
};
try
{
var Scope = new ManagementScope(ManagementPath, Options);
Scope.Connect();
var Query = new SelectQuery("Win32_OperatingSystem");
using (var Searcher = new ManagementObjectSearcher(Scope, Query))
foreach (ManagementObject OS in Searcher.Get())
{
using (ManagementBaseObject InParams = OS.GetMethodParameters("Win32Shutdown"))
{
InParams["Flags"] = 6;
ManagementBaseObject OutParams = await Task.Run(() => OS.InvokeMethod("Win32Shutdown", InParams, null));
OutParams.Dispose();
}
}
}
catch (Exception e)
{
Logger.Log(new Elmah.Error(e));
return(false);
}
return(true);
}
/*
* /// <summary>
* /// Code to execute after the install has completed.
* /// </summary>
* private void IRServerInstaller_AfterInstall(object sender, InstallEventArgs e)
* {
* // TODO: Set the restart options here.
*
* // Start the service ...
* //using (ServiceController serviceController = new ServiceController(Program.ServiceName))
* //serviceController.Start();
* }
*/
/// <summary>
/// Used to set the "Allow service to interact with the desktop" setting.
/// </summary>
private void IRServerInstaller_Committing(object sender, InstallEventArgs e)
{
ManagementBaseObject inParam = null;
ManagementBaseObject outParam = null;
try
{
ConnectionOptions coOptions = new ConnectionOptions();
coOptions.Impersonation = ImpersonationLevel.Impersonate;
ManagementScope mgmtScope = new ManagementScope(@"root\CIMV2", coOptions);
mgmtScope.Connect();
string path = string.Format("Win32_Service.Name='{0}'", Shared.ServerName);
using (ManagementObject wmiService = new ManagementObject(path))
{
inParam = wmiService.GetMethodParameters("Change");
inParam["DesktopInteract"] = true;
inParam["PathName"] = "\"" + Assembly.GetExecutingAssembly().Location + "\" -SERVICE";
outParam = wmiService.InvokeMethod("Change", inParam, null);
}
}
finally
{
if (inParam != null)
{
inParam.Dispose();
}
if (outParam != null)
{
outParam.Dispose();
}
}
}
