public LibraryItem[] GetClusters()
{
List<LibraryItem> items = new List<LibraryItem>();
using (WSPVirtualMachineManagementServiceClient client = GetVMMSClient())
{
if (client.State != CommunicationState.Opened)
{
client.Open();
}
HostClusterInfo[] ci = client.GetHostClusters();
if (ci == null || ci.Length == 0)
{
throw new Exception("Clusters is not found.");
}
for (int i = 0; i < ci.Length; i++)
{
LibraryItem newItem = new LibraryItem();
HostClusterInfo hostInfo = ci[i];
newItem.Description = hostInfo.Description;
newItem.Name = hostInfo.Name;
newItem.Path = hostInfo.Id.ToString();
//TODO нужно думать
newItem.ProcessVolume = hostInfo.AvailableStorageNode.CoresPerCPU;
newItem.ProvisionComputerName = true;
// Get host's networks
newItem.Networks = GetVirtualNetworkByHostInfo(hostInfo.AvailableStorageNode);
items.Add(newItem);
}
client.Close();
}
return items.ToArray();
}
public LibraryItem[] GetHosts()
{
List<LibraryItem> items = new List<LibraryItem>();
using (WSPVirtualMachineManagementServiceClient client = GetVMMSClient())
{
if (client.State != CommunicationState.Opened)
{
client.Open();
}
HostInfo[] ti = null;
try
{
ti = client.GetHosts();
}
catch (Exception ex)
{
throw new Exception("GetHost Failed", ex);
}
if (ti == null || ti.Length == 0)
{
throw new Exception("Hosts is not found.");
}
for (int i = 0; i < ti.Length; i++)
{
LibraryItem newItem = new LibraryItem();
HostInfo hostInfo = ti[i];
newItem.Description = hostInfo.Description;
newItem.Name = hostInfo.ComputerName;
newItem.Path = hostInfo.Id.ToString();
newItem.ProcessVolume = hostInfo.CoresPerCPU;
newItem.ProvisionComputerName = true;
// Get host's networks
newItem.Networks = GetVirtualNetworkByHostInfo(hostInfo);
items.Add(newItem);
}
}
return items.ToArray();
}
internal static void CreateVirtualMachineInternal(string taskId, VirtualMachine vm, LibraryItem osTemplate,
int externalAddressesNumber, bool randomExternalAddresses, int[] externalAddresses,
int privateAddressesNumber, bool randomPrivateAddresses, string[] privateAddresses,
string summaryLetterEmail)
{
// start task
TaskManager.StartTask(taskId, "VPS2012", "CREATE", vm.Name, vm.Id, vm.PackageId);
try
{
// set Error flag
vm.ProvisioningStatus = VirtualMachineProvisioningStatus.Error;
// load proxy
VirtualizationServer2012 vs = GetVirtualizationProxy(vm.ServiceId);
// load service settings
StringDictionary settings = ServerController.GetServiceSettings(vm.ServiceId);
#region Setup External network
TaskManager.Write("VPS_CREATE_SETUP_EXTERNAL_NETWORK");
TaskManager.IndicatorCurrent = -1; // Some providers (for example HyperV2012R2) could not provide progress
try
{
if (vm.ExternalNetworkEnabled)
{
// provision IP addresses
ResultObject privResult = AddVirtualMachineExternalIPAddresses(vm.Id, randomExternalAddresses,
externalAddressesNumber, externalAddresses, false);
// set primary IP address
NetworkAdapterDetails extNic = GetExternalNetworkAdapterDetails(vm.Id);
if (extNic.IPAddresses.Length > 0)
SetVirtualMachinePrimaryExternalIPAddress(vm.Id, extNic.IPAddresses[0].AddressId, false);
// connect to network
vm.ExternalSwitchId = settings["ExternalNetworkId"];
vm.ExternalNicMacAddress = GenerateMacAddress();
}
else
{
TaskManager.Write("VPS_CREATE_SETUP_EXTERNAL_NETWORK_SKIP");
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "VPS_CREATE_SETUP_EXTERNAL_NETWORK_ERROR");
return;
}
#endregion
#region Setup Management network
TaskManager.Write("VPS_CREATE_SETUP_MANAGEMENT_NETWORK");
TaskManager.IndicatorCurrent = -1; // Some providers (for example HyperV2012R2) could not provide progress
try
{
if (vm.ManagementNetworkEnabled)
{
// check that package contains unassigned IP
// that could be re-used
List<PackageIPAddress> packageIps = ServerController.GetPackageUnassignedIPAddresses(
vm.PackageId, IPAddressPool.VpsManagementNetwork);
if (packageIps.Count == 0)
{
// must be fresh space
// allocate package IP from the pool
List<IPAddressInfo> ips = ServerController.GetUnallottedIPAddresses(
vm.PackageId, ResourceGroups.VPS2012, IPAddressPool.VpsManagementNetwork);
if (ips.Count > 0)
{
// assign IP to the package
ServerController.AllocatePackageIPAddresses(vm.PackageId, new int[] { ips[0].AddressId });
// re-read package IPs
packageIps = ServerController.GetPackageUnassignedIPAddresses(
vm.PackageId, IPAddressPool.VpsManagementNetwork);
}
else
{
// nothing to allocate - pool empty
TaskManager.WriteWarning("VPS_CREATE_SETUP_MANAGEMENT_NETWORK_POOL_EMPTY");
}
}
if (packageIps.Count > 0)
{
// assign to the item
ServerController.AddItemIPAddress(vm.Id, packageIps[0].PackageAddressID);
// set primary IP address
ServerController.SetItemPrimaryIPAddress(vm.Id, packageIps[0].PackageAddressID);
// connect to network
vm.ManagementSwitchId = settings["ManagementNetworkId"];
vm.ManagementNicMacAddress = GenerateMacAddress();
}
}
else
{
TaskManager.Write("VPS_CREATE_SETUP_MANAGEMENT_NETWORK_SKIP");
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "VPS_CREATE_SETUP_MANAGEMENT_NETWORK_ERROR");
return;
}
#endregion
#region Setup Private network
TaskManager.Write("VPS_CREATE_SETUP_PRIVATE_NETWORK");
TaskManager.IndicatorCurrent = -1; // Some providers (for example HyperV2012R2) could not provide progress
try
{
if (vm.PrivateNetworkEnabled)
{
NetworkAdapterDetails privNic = GetPrivateNetworkDetailsInternal(vm.ServiceId);
if (!privNic.IsDHCP)
{
// provision IP addresses
ResultObject extResult = AddVirtualMachinePrivateIPAddresses(vm.Id, randomPrivateAddresses, privateAddressesNumber, privateAddresses, false);
// set primary IP address
privNic = GetPrivateNetworkAdapterDetails(vm.Id);
if (privNic.IPAddresses.Length > 0)
SetVirtualMachinePrimaryPrivateIPAddress(vm.Id, privNic.IPAddresses[0].AddressId, false);
}
// connecto to network
vm.PrivateSwitchId = settings["PrivateNetworkId"];
if (String.IsNullOrEmpty(vm.PrivateSwitchId))
{
// create/load private virtual switch
vm.PrivateSwitchId = EnsurePrivateVirtualSwitch(vm);
if (vm.PrivateSwitchId == null)
return; // exit on error
}
vm.PrivateNicMacAddress = GenerateMacAddress();
}
else
{
TaskManager.Write("VPS_CREATE_SETUP_PRIVATE_NETWORK_SKIP");
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "VPS_CREATE_SETUP_PRIVATE_NETWORK_ERROR");
return;
}
#endregion
// update service item
VirtualMachineProvisioningStatus status = vm.ProvisioningStatus;
vm.ProvisioningStatus = VirtualMachineProvisioningStatus.InProgress;
PackageController.UpdatePackageItem(vm);
vm.ProvisioningStatus = status;
#region Copy/convert VHD
JobResult result = null;
ReturnCode code = ReturnCode.OK;
TaskManager.Write("VPS_CREATE_OS_TEMPLATE", osTemplate.Name);
TaskManager.Write("VPS_CREATE_CONVERT_VHD");
TaskManager.Write("VPS_CREATE_CONVERT_SOURCE_VHD", vm.OperatingSystemTemplatePath);
TaskManager.Write("VPS_CREATE_CONVERT_DEST_VHD", vm.VirtualHardDrivePath);
TaskManager.IndicatorCurrent = -1; // Some providers (for example HyperV2012R2) could not provide progress
try
{
// convert VHD
VirtualHardDiskType vhdType = (VirtualHardDiskType)Enum.Parse(typeof(VirtualHardDiskType), settings["VirtualDiskType"], true);
result = vs.ConvertVirtualHardDisk(vm.OperatingSystemTemplatePath, vm.VirtualHardDrivePath, vhdType);
// check return
if (result.ReturnValue != ReturnCode.JobStarted)
{
TaskManager.WriteError("VPS_CREATE_CONVERT_VHD_ERROR_JOB_START", result.ReturnValue.ToString());
return;
}
// wait for completion
if (!JobCompleted(vs, result.Job))
{
TaskManager.WriteError("VPS_CREATE_CONVERT_VHD_ERROR_JOB_EXEC", result.Job.ErrorDescription.ToString());
return;
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "VPS_CREATE_CONVERT_VHD_ERROR");
return;
}
#endregion
#region Get VHD info
VirtualHardDiskInfo vhdInfo = null;
try
{
vhdInfo = vs.GetVirtualHardDiskInfo(vm.VirtualHardDrivePath);
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "VPS_CREATE_GET_VHD_INFO");
return;
}
if (vhdInfo == null || vhdInfo.InUse)
{
// master VHD is in use
TaskManager.WriteError("VPS_CREATE_MASTER_VHD_IN_USE");
return;
}
// check if it should be expanded
int hddSizeGB = Convert.ToInt32(vhdInfo.MaxInternalSize / Size1G);
TaskManager.Write("VPS_CREATE_EXPAND_SOURCE_VHD_SIZE", hddSizeGB.ToString());
TaskManager.Write("VPS_CREATE_EXPAND_DEST_VHD_SIZE", vm.HddSize.ToString());
#endregion
#region Expand VHD
bool expanded = false;
if (vm.HddSize > hddSizeGB)
{
TaskManager.Write("VPS_CREATE_EXPAND_VHD");
TaskManager.IndicatorCurrent = -1; // Some providers (for example HyperV2012R2) could not provide progress
// expand VHD
try
{
result = vs.ExpandVirtualHardDisk(vm.VirtualHardDrivePath, (ulong)vm.HddSize);
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "VPS_CREATE_EXPAND_VHD_ERROR");
return;
}
// check return
if (result.ReturnValue != ReturnCode.JobStarted)
{
// error starting Expand job
TaskManager.WriteError("VPS_CREATE_EXPAND_VHD_ERROR_JOB_START", result.ReturnValue.ToString());
return;
}
// wait for completion
if (!JobCompleted(vs, result.Job))
{
// error executing Expand job
TaskManager.WriteError("VPS_CREATE_EXPAND_VHD_ERROR_JOB_EXEC", result.Job.ErrorDescription);
return;
}
expanded = true;
}
else
{
// skip expanding
TaskManager.Write("VPS_CREATE_EXPAND_VHD_SKIP");
}
#endregion
#region Process VHD contents
// mount VHD
if ((expanded && osTemplate.ProcessVolume != -1)
|| (osTemplate.SysprepFiles != null && osTemplate.SysprepFiles.Length > 0))
{
try
{
#region Mount VHD
MountedDiskInfo mountedInfo = vs.MountVirtualHardDisk(vm.VirtualHardDrivePath);
if (mountedInfo == null)
{
// mount returned NULL
TaskManager.WriteError("VPS_CREATE_MOUNT_VHD_NULL");
return;
}
#endregion
#region Expand volume
if (expanded && osTemplate.ProcessVolume != -1 && mountedInfo.DiskVolumes.Length > 0)
{
try
{
vs.ExpandDiskVolume(mountedInfo.DiskAddress, mountedInfo.DiskVolumes[osTemplate.ProcessVolume]);
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "VPS_CREATE_DISKPART_ERROR");
}
}
else
{
TaskManager.Write("VPS_CREATE_EXPAND_VHD_SKIP_NO_VOLUMES");
}
#endregion
#region Sysprep
if (mountedInfo.DiskVolumes.Length > 0
&& osTemplate.ProcessVolume != -1
&& osTemplate.SysprepFiles != null && osTemplate.SysprepFiles.Length > 0)
{
foreach (string remoteFile in osTemplate.SysprepFiles)
{
try
{
TaskManager.Write("VPS_CREATE_SYSPREP_FILE", remoteFile);
// build remote path
string path = remoteFile;
if (!remoteFile.StartsWith("\\"))
path = remoteFile.Substring(remoteFile.IndexOf("\\"));
path = String.Format("{0}:{1}", mountedInfo.DiskVolumes[osTemplate.ProcessVolume], path);
// read remote file
string contents = vs.ReadRemoteFile(path);
if (contents == null)
{
TaskManager.Write("VPS_CREATE_SYSPREP_FILE_NOT_FOUND", remoteFile);
continue;
}
// process file contents
contents = EvaluateVirtualMachineTemplate(vm.Id, false, false, contents);
// write remote file
vs.WriteRemoteFile(path, contents);
}
catch (Exception ex)
{
TaskManager.WriteError("VPS_CREATE_SYSPREP_FILE_ERROR", ex.Message);
}
}
}
#endregion
#region Unmount VHD
try
{
code = vs.UnmountVirtualHardDisk(vm.VirtualHardDrivePath);
if (code != ReturnCode.OK)
{
TaskManager.WriteError("VPS_CREATE_UNMOUNT_ERROR_JOB_START", code.ToString());
return;
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "VPS_CREATE_UNMOUNT_ERROR");
return;
}
#endregion
}
catch (Exception ex)
{
// error mounting
TaskManager.WriteError(ex, "VPS_CREATE_MOUNT_VHD");
return;
}
} // end if (expanded ...
#endregion
#region Create Virtual Machine
TaskManager.Write("VPS_CREATE_CPU_CORES", vm.CpuCores.ToString());
TaskManager.Write("VPS_CREATE_RAM_SIZE", vm.RamSize.ToString());
TaskManager.Write("VPS_CREATE_CREATE_VM");
TaskManager.IndicatorCurrent = -1; // Some providers (for example HyperV2012R2) could not provide progress
// create virtual machine
try
{
// create
vm = vs.CreateVirtualMachine(vm);
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "VPS_CREATE_CREATE_VM_ERROR");
return;
}
// update meta item
PackageController.UpdatePackageItem(vm);
TaskManager.Write("VPS_CREATE_CREATED_VM");
#endregion
// set OK flag
vm.ProvisioningStatus = VirtualMachineProvisioningStatus.OK;
#region Send KVP
// configure computer name
if (osTemplate.ProvisionComputerName)
{
TaskManager.Write("VPS_CREATE_SET_COMPUTER_NAME_KVP");
SendComputerNameKVP(vm.Id, vm.Name);
}
// change administrator password
if (osTemplate.ProvisionAdministratorPassword)
{
TaskManager.Write("VPS_CREATE_SET_PASSWORD_KVP");
SendAdministratorPasswordKVP(vm.Id, CryptoUtils.Decrypt(vm.AdministratorPassword));
}
// configure network adapters
if(osTemplate.ProvisionNetworkAdapters)
{
// external NIC
TaskManager.Write("VPS_CREATE_SET_EXTERNAL_NIC_KVP");
if (vm.ExternalNetworkEnabled)
{
result = SendNetworkAdapterKVP(vm.Id, "External");
if (result.ReturnValue != ReturnCode.JobStarted)
TaskManager.WriteWarning("VPS_CREATE_SET_EXTERNAL_NIC_KVP_ERROR", result.ReturnValue.ToString());
}
// management NIC
TaskManager.Write("VPS_CREATE_SET_MANAGEMENT_NIC_KVP");
if (vm.ManagementNetworkEnabled)
{
result = SendNetworkAdapterKVP(vm.Id, "Management");
if (result.ReturnValue != ReturnCode.JobStarted)
TaskManager.WriteWarning("VPS_CREATE_SET_MANAGEMENT_NIC_KVP_ERROR", result.ReturnValue.ToString());
}
// private NIC
TaskManager.Write("VPS_CREATE_SET_PRIVATE_NIC_KVP");
if (vm.PrivateNetworkEnabled)
{
result = SendNetworkAdapterKVP(vm.Id, "Private");
if (result.ReturnValue != ReturnCode.JobStarted)
TaskManager.WriteWarning("VPS_CREATE_SET_PRIVATE_NIC_KVP_ERROR", result.ReturnValue.ToString());
}
}
#endregion
#region Start VPS
TaskManager.Write("VPS_CREATE_START_VPS");
TaskManager.IndicatorCurrent = -1; // Some providers (for example HyperV2012R2) could not provide progress
try
{
// start virtual machine
result = vs.ChangeVirtualMachineState(vm.VirtualMachineId, VirtualMachineRequestedState.Start);
// check return
if (result.ReturnValue == ReturnCode.JobStarted)
{
// wait for completion
if (!JobCompleted(vs, result.Job))
{
TaskManager.WriteWarning("VPS_CREATE_START_VPS_ERROR_JOB_EXEC", result.Job.ErrorDescription.ToString());
}
}
else
{
TaskManager.WriteWarning("VPS_CREATE_START_VPS_ERROR_JOB_START", result.ReturnValue.ToString());
}
}
catch (Exception ex)
{
TaskManager.WriteWarning("VPS_CREATE_START_VPS_ERROR", ex.Message);
}
TaskManager.Write("VPS_CREATE_STARTED_VPS");
#endregion
#region Send Summary letter
// send summary e-mail
if (!String.IsNullOrEmpty(summaryLetterEmail))
{
SendVirtualMachineSummaryLetter(vm.Id, summaryLetterEmail, null, true);
}
#endregion
}
catch (Exception ex)
{
TaskManager.WriteError(ex, VirtualizationErrorCodes.CREATE_ERROR);
return;
}
finally
{
// reset task ID
vm.CurrentTaskId = null;
PackageController.UpdatePackageItem(vm);
if (vm.ProvisioningStatus == VirtualMachineProvisioningStatus.OK)
TaskManager.Write("VPS_CREATE_SUCCESS");
else if (vm.ProvisioningStatus == VirtualMachineProvisioningStatus.Error)
TaskManager.Write("VPS_CREATE_ERROR_END");
// complete task
TaskManager.CompleteTask();
}
}
public LibraryItem[] GetOSLibraryItems()
{
List<LibraryItem> items = new List<LibraryItem>();
using (WSPVirtualMachineManagementServiceClient client = GetVMMSClient())
{
TemplateInfo[] ti = client.GetTemplates();
for (int i = 0; i < ti.Length; i++)
{
LibraryItem newItem = new LibraryItem();
newItem.Description = ti[i].OperatingSystem.Name;
newItem.Name = ti[i].Name;
newItem.Path = ti[i].Id.ToString();
newItem.ProcessVolume = ti[i].CPUCount;
newItem.ProvisionAdministratorPassword = ti[i].AdminPasswordhasValue;
newItem.ProvisionComputerName = true;
newItem.ProvisionNetworkAdapters = (ti[i].VirtualNetworkAdapters.Length > 0);
newItem.LegacyNetworkAdapter = (ti[i].NetworkUtilization > 0);
items.Add(newItem);
}
}
return items.ToArray();
}
private List<LibraryItem> GetDvds()
{
var result = new List<LibraryItem>();
foreach (RepeaterItem item in repDvdLibrary.Items)
{
var dvd = new LibraryItem();
dvd.Name = GetTextBoxText(item, "txtDvdName");
dvd.Description = GetTextBoxText(item, "txtDvdDescription");
dvd.Path = GetTextBoxText(item, "txtDvdFileName");
result.Add(dvd);
}
return result;
}
public LibraryItem[] GetLibraryItems(string path)
{
path = Path.Combine(FileUtils.EvaluateSystemVariables(path), LIBRARY_INDEX_FILE_NAME);
// convert to UNC if it is a remote computer
path = ConvertToUNC(path);
if (!File.Exists(path))
{
Log.WriteWarning("The folder does not contain 'index.xml' file: {0}", path);
return null;
}
// create list
List<LibraryItem> items = new List<LibraryItem>();
// load xml
XmlDocument xml = new XmlDocument();
xml.Load(path);
XmlNodeList nodeItems = xml.SelectNodes("/items/item");
if(nodeItems.Count == 0)
Log.WriteWarning("index.xml found, but contains 0 items: {0}", path);
foreach (XmlNode nodeItem in nodeItems)
{
LibraryItem item = new LibraryItem();
item.Path = nodeItem.Attributes["path"].Value;
// optional attributes
if (nodeItem.Attributes["diskSize"] != null)
item.DiskSize = Int32.Parse(nodeItem.Attributes["diskSize"].Value);
if (nodeItem.Attributes["legacyNetworkAdapter"] != null)
item.LegacyNetworkAdapter = Boolean.Parse(nodeItem.Attributes["legacyNetworkAdapter"].Value);
item.ProcessVolume = 0; // process (extend and sysprep) 1st volume by default
if (nodeItem.Attributes["processVolume"] != null)
item.ProcessVolume = Int32.Parse(nodeItem.Attributes["processVolume"].Value);
if (nodeItem.Attributes["remoteDesktop"] != null)
item.RemoteDesktop = Boolean.Parse(nodeItem.Attributes["remoteDesktop"].Value);
// inner nodes
item.Name = nodeItem.SelectSingleNode("name").InnerText;
item.Description = nodeItem.SelectSingleNode("description").InnerText;
// sysprep files
XmlNodeList nodesSyspep = nodeItem.SelectNodes("provisioning/sysprep");
List<string> sysprepFiles = new List<string>();
foreach (XmlNode nodeSyspep in nodesSyspep)
{
if (nodeSyspep.Attributes["file"] != null)
sysprepFiles.Add(nodeSyspep.Attributes["file"].Value);
}
item.SysprepFiles = sysprepFiles.ToArray();
// vmconfig
XmlNode nodeVmConfig = nodeItem.SelectSingleNode("provisioning/vmconfig");
if (nodeVmConfig != null)
{
if (nodeVmConfig.Attributes["computerName"] != null)
item.ProvisionComputerName = Boolean.Parse(nodeVmConfig.Attributes["computerName"].Value);
if (nodeVmConfig.Attributes["administratorPassword"] != null)
item.ProvisionAdministratorPassword = Boolean.Parse(nodeVmConfig.Attributes["administratorPassword"].Value);
if (nodeVmConfig.Attributes["networkAdapters"] != null)
item.ProvisionNetworkAdapters = Boolean.Parse(nodeVmConfig.Attributes["networkAdapters"].Value);
}
items.Add(item);
}
return items.ToArray();
}
private List<LibraryItem> GetOsTemplates()
{
var result = new List<LibraryItem>();
foreach (RepeaterItem item in repOsTemplates.Items)
{
var template = new LibraryItem();
int processVolume;
template.Name = GetTextBoxText(item, "txtTemplateName");
template.Path = GetTextBoxText(item, "txtTemplateFileName");
int.TryParse(GetTextBoxText(item, "txtProcessVolume"), out processVolume);
template.ProcessVolume = processVolume;
template.LegacyNetworkAdapter = GetCheckBoxValue(item, "chkLegacyNetworkAdapter");
template.RemoteDesktop = true; // obsolete
template.ProvisionComputerName = GetCheckBoxValue(item, "chkCanSetComputerName");
template.ProvisionAdministratorPassword = GetCheckBoxValue(item, "chkCanSetAdminPass");
template.ProvisionNetworkAdapters = GetCheckBoxValue(item, "chkCanSetNetwork");
var syspreps = GetTextBoxText(item, "txtSysprep").Split(new[] {";"}, StringSplitOptions.RemoveEmptyEntries);
template.SysprepFiles = syspreps.Select(s=>s.Trim()).ToArray();
result.Add(template);
}
return result;
}
private void Load(string xmlText)
{
// create list
List <LibraryItem> items = new List <LibraryItem>();
if (string.IsNullOrEmpty(xmlText))
{
LibraryItems = items.ToArray();
return;
}
// load xml
XmlDocument xml = new XmlDocument();
xml.LoadXml(xmlText);
XmlNodeList nodeItems = xml.SelectNodes("/items/item");
foreach (XmlNode nodeItem in nodeItems)
{
LibraryItem item = new LibraryItem();
item.Path = nodeItem.Attributes["path"].Value;
// optional attributes
if (nodeItem.Attributes["diskSize"] != null)
{
item.DiskSize = Int32.Parse(nodeItem.Attributes["diskSize"].Value);
}
if (nodeItem.Attributes["legacyNetworkAdapter"] != null)
{
item.LegacyNetworkAdapter = Boolean.Parse(nodeItem.Attributes["legacyNetworkAdapter"].Value);
}
item.ProcessVolume = 0; // process (extend and sysprep) 1st volume by default
if (nodeItem.Attributes["processVolume"] != null)
{
item.ProcessVolume = Int32.Parse(nodeItem.Attributes["processVolume"].Value);
}
if (nodeItem.Attributes["remoteDesktop"] != null)
{
item.RemoteDesktop = Boolean.Parse(nodeItem.Attributes["remoteDesktop"].Value);
}
// inner nodes
item.Name = nodeItem.SelectSingleNode("name").InnerText;
var descriptionNode = nodeItem.SelectSingleNode("description");
if (descriptionNode != null)
{
item.Description = descriptionNode.InnerText;
}
// sysprep files
XmlNodeList nodesSyspep = nodeItem.SelectNodes("provisioning/sysprep");
List <string> sysprepFiles = new List <string>();
foreach (XmlNode nodeSyspep in nodesSyspep)
{
if (nodeSyspep.Attributes["file"] != null)
{
sysprepFiles.Add(nodeSyspep.Attributes["file"].Value);
}
}
item.SysprepFiles = sysprepFiles.ToArray();
// vmconfig
XmlNode nodeVmConfig = nodeItem.SelectSingleNode("provisioning/vmconfig");
if (nodeVmConfig != null)
{
if (nodeVmConfig.Attributes["computerName"] != null)
{
item.ProvisionComputerName = Boolean.Parse(nodeVmConfig.Attributes["computerName"].Value);
}
if (nodeVmConfig.Attributes["administratorPassword"] != null)
{
item.ProvisionAdministratorPassword =
Boolean.Parse(nodeVmConfig.Attributes["administratorPassword"].Value);
}
if (nodeVmConfig.Attributes["networkAdapters"] != null)
{
item.ProvisionNetworkAdapters = Boolean.Parse(nodeVmConfig.Attributes["networkAdapters"].Value);
}
}
items.Add(item);
}
LibraryItems = items.ToArray();
}
private void Load(string xmlText)
{
// create list
List<LibraryItem> items = new List<LibraryItem>();
if (string.IsNullOrEmpty(xmlText))
{
LibraryItems = items.ToArray();
return;
}
// load xml
XmlDocument xml = new XmlDocument();
xml.LoadXml(xmlText);
XmlNodeList nodeItems = xml.SelectNodes("/items/item");
foreach (XmlNode nodeItem in nodeItems)
{
LibraryItem item = new LibraryItem();
item.Path = nodeItem.Attributes["path"].Value;
// optional attributes
if (nodeItem.Attributes["diskSize"] != null)
item.DiskSize = Int32.Parse(nodeItem.Attributes["diskSize"].Value);
if (nodeItem.Attributes["legacyNetworkAdapter"] != null)
item.LegacyNetworkAdapter = Boolean.Parse(nodeItem.Attributes["legacyNetworkAdapter"].Value);
item.ProcessVolume = 0; // process (extend and sysprep) 1st volume by default
if (nodeItem.Attributes["processVolume"] != null)
item.ProcessVolume = Int32.Parse(nodeItem.Attributes["processVolume"].Value);
if (nodeItem.Attributes["remoteDesktop"] != null)
item.RemoteDesktop = Boolean.Parse(nodeItem.Attributes["remoteDesktop"].Value);
// inner nodes
item.Name = nodeItem.SelectSingleNode("name").InnerText;
var descriptionNode = nodeItem.SelectSingleNode("description");
if (descriptionNode != null)
item.Description = descriptionNode.InnerText;
// sysprep files
XmlNodeList nodesSyspep = nodeItem.SelectNodes("provisioning/sysprep");
List<string> sysprepFiles = new List<string>();
foreach (XmlNode nodeSyspep in nodesSyspep)
{
if (nodeSyspep.Attributes["file"] != null)
sysprepFiles.Add(nodeSyspep.Attributes["file"].Value);
}
item.SysprepFiles = sysprepFiles.ToArray();
// vmconfig
XmlNode nodeVmConfig = nodeItem.SelectSingleNode("provisioning/vmconfig");
if (nodeVmConfig != null)
{
if (nodeVmConfig.Attributes["computerName"] != null)
item.ProvisionComputerName = Boolean.Parse(nodeVmConfig.Attributes["computerName"].Value);
if (nodeVmConfig.Attributes["administratorPassword"] != null)
item.ProvisionAdministratorPassword =
Boolean.Parse(nodeVmConfig.Attributes["administratorPassword"].Value);
if (nodeVmConfig.Attributes["networkAdapters"] != null)
item.ProvisionNetworkAdapters = Boolean.Parse(nodeVmConfig.Attributes["networkAdapters"].Value);
}
items.Add(item);
}
LibraryItems = items.ToArray();
}
public ConfigFile(LibraryItem[] libraryItems)
{
LibraryItems = libraryItems;
Load(libraryItems);
}
private void Load(LibraryItem[] libraryItems)
{
List<string> items = new List<string>();
foreach (var libraryItem in libraryItems)
{
var sysprep = "";
if (libraryItem.SysprepFiles != null && libraryItem.SysprepFiles.Any())
sysprep = string.Join("", libraryItem.SysprepFiles.Select(s => string.Format(sysprepTemplate, s)).ToArray());
items.Add(string.Format(itemTemplate, libraryItem.Path, libraryItem.LegacyNetworkAdapter,
libraryItem.RemoteDesktop, libraryItem.ProcessVolume, libraryItem.Name, libraryItem.Description,
sysprep, libraryItem.ProvisionComputerName, libraryItem.ProvisionAdministratorPassword,
libraryItem.ProvisionNetworkAdapters));
}
Xml = string.Format(resultTemplate, string.Join("", items.ToArray()));
}
