mirror of
https://github.com/xcp-ng/xenadmin.git
synced 2024-12-22 16:36:03 +01:00
327 lines
14 KiB
C#
327 lines
14 KiB
C#
/* Copyright (c) Citrix Systems Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms,
|
|
* with or without modification, are permitted provided
|
|
* that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above
|
|
* copyright notice, this list of conditions and the
|
|
* following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the
|
|
* following disclaimer in the documentation and/or other
|
|
* materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Xml;
|
|
using XenAdmin.Core;
|
|
using XenAdmin.Network;
|
|
using XenAPI;
|
|
using System.Text.RegularExpressions;
|
|
|
|
using XenAdmin.Network.StorageLink;
|
|
|
|
namespace XenAdmin.Actions
|
|
{
|
|
/// <summary>
|
|
/// Performs a scan of a CSLG server for storage pools given a storage system.
|
|
/// </summary>
|
|
public class SrCslgStoragePoolScanAction : SrCslgScanAction
|
|
{
|
|
private static readonly log4net.ILog Log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
private readonly string _storageSystemId;
|
|
private ReadOnlyCollection<CslgStoragePool> _cslgStoragePools;
|
|
private List<StorageLinkConnection> _SLConnections;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="SrCslgStoragePoolScanAction"/> class.
|
|
/// </summary>
|
|
/// <param name="connection">The connection.</param>
|
|
/// <param name="hostname">The hostname.</param>
|
|
/// <param name="username">The username.</param>
|
|
/// <param name="passwordSecret">The password secret.</param>
|
|
/// <param name="storageSystemId">The storage system id.</param>
|
|
public SrCslgStoragePoolScanAction(IXenConnection connection, List<StorageLinkConnection> storageLinkConnections, string hostname, string username, string passwordSecret, string storageSystemId)
|
|
: base(connection, hostname, username, passwordSecret)
|
|
{
|
|
Util.ThrowIfStringParameterNullOrEmpty(storageSystemId, "storageSystemId");
|
|
|
|
_storageSystemId = storageSystemId;
|
|
_SLConnections = storageLinkConnections;
|
|
|
|
}
|
|
|
|
private readonly string _adapterId;
|
|
public SrCslgStoragePoolScanAction(IXenConnection connection, string hostname, string username, string password, string storagesystemid, string adapterid)
|
|
: base(connection, hostname, username, password)
|
|
{
|
|
_storageSystemId = storagesystemid;
|
|
_adapterId = adapterid;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the CSLG system storages. Returns null before the action has been run.
|
|
/// </summary>
|
|
/// <value>The CSLG system storages.</value>
|
|
public ReadOnlyCollection<CslgStoragePool> CslgStoragePools
|
|
{
|
|
get
|
|
{
|
|
return _cslgStoragePools;
|
|
}
|
|
}
|
|
|
|
private List<CslgStoragePool> ParseStoragePoolXml(String xml)
|
|
{
|
|
List<CslgStoragePool> output = new List<CslgStoragePool>();
|
|
XmlDocument doc = new XmlDocument();
|
|
doc.LoadXml(xml);
|
|
|
|
foreach (XmlNode storagePoolInfo in doc.GetElementsByTagName("csl__storagePoolInfo"))
|
|
{
|
|
string displayName = GetXmlNodeInnerText(storagePoolInfo, "displayName").Trim();
|
|
string storagePoolId = GetXmlNodeInnerText(storagePoolInfo, "storagePoolId").Trim();
|
|
List<string> raidTypes = new List<string>();
|
|
foreach (var raid in GetXmlChildNodeInnerTexts(storagePoolInfo, "provisioningOptions/supportedRaidTypes/raidType"))
|
|
{
|
|
raidTypes.Add(raid.Trim());
|
|
}
|
|
List<CslgParameter> provisioningTypes = new List<CslgParameter>();
|
|
string parentStoragePoolId = GetXmlNodeInnerText(storagePoolInfo, "parentStoragePoolId");
|
|
|
|
foreach (string innerText in GetXmlChildNodeInnerTexts(storagePoolInfo, "provisioningOptions/supportedProvisioningTypes/provisioningType"))
|
|
{
|
|
var trimmedInnerText = innerText.Trim();
|
|
// CVSM-3277: bridge returns "FULL" for some versions but "THICK" is required.
|
|
if (trimmedInnerText == "FULL" || trimmedInnerText == "THICK")
|
|
{
|
|
provisioningTypes.Add(new CslgParameter("THICK", Messages.NEWSR_CSLG_THICK_PROVISIONING));
|
|
}
|
|
else if (trimmedInnerText == "THIN")
|
|
{
|
|
provisioningTypes.Add(new CslgParameter(trimmedInnerText, Messages.NEWSR_CSLG_THIN_PROVISIONING));
|
|
}
|
|
}
|
|
|
|
if (raidTypes.Count == 0)
|
|
{
|
|
raidTypes.Add("RAID_NONE");
|
|
}
|
|
|
|
if (provisioningTypes.Count == 0)
|
|
{
|
|
provisioningTypes.Add(new CslgParameter(null, Messages.NEWSR_CSLG_DEFAULT_PROVISIONING));
|
|
}
|
|
|
|
if (Helpers.BostonOrGreater(Connection))
|
|
{
|
|
uint capacity = 0;
|
|
uint usedSpace = 0;
|
|
try
|
|
{
|
|
capacity = UInt32.Parse(GetXmlNodeInnerText(storagePoolInfo, "sizeInMB").Trim());
|
|
usedSpace = capacity - UInt32.Parse(GetXmlNodeInnerText(storagePoolInfo, "freeSpaceInMB").Trim());
|
|
}
|
|
catch { }
|
|
|
|
StorageLinkPool storageLinkPool = new StorageLinkPool(null, storagePoolId, displayName, parentStoragePoolId, _storageSystemId, capacity, usedSpace,
|
|
(StorageLinkEnums.RaidType)Enum.Parse(typeof(StorageLinkEnums.RaidType), raidTypes[0].ToUpper()),
|
|
(StorageLinkEnums.ProvisioningType)Enum.Parse(typeof(StorageLinkEnums.ProvisioningType), provisioningTypes[0].Name.ToUpper()));
|
|
output.Add(new CslgStoragePool(displayName, storagePoolId, raidTypes, provisioningTypes, !string.IsNullOrEmpty(parentStoragePoolId), storageLinkPool));
|
|
}
|
|
else
|
|
output.Add(new CslgStoragePool(displayName, storagePoolId, raidTypes, provisioningTypes, !string.IsNullOrEmpty(parentStoragePoolId), null));
|
|
}
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Runs this instance.
|
|
/// </summary>
|
|
protected override void Run()
|
|
{
|
|
Dictionary<string, string> dconf = GetAuthenticationDeviceConfig();
|
|
dconf["storageSystemId"] = _storageSystemId;
|
|
if (!string.IsNullOrEmpty(_adapterId))
|
|
dconf["adapterid"] = _adapterId;
|
|
Log.DebugFormat("Attempting to find pools on {0}.", _storageSystemId);
|
|
|
|
if (Connection != null && (
|
|
(!Helpers.CowleyOrGreater(Connection) && Helpers.MidnightRideOrGreater(Connection)))
|
|
|| Helpers.BostonOrGreater(Connection)
|
|
)
|
|
{
|
|
RunProbe(dconf);
|
|
if (!string.IsNullOrEmpty(Result))
|
|
_cslgStoragePools = new ReadOnlyCollection<CslgStoragePool>(ParseStoragePoolXml(Util.GetContentsOfValueNode(Result)));
|
|
}
|
|
else
|
|
{
|
|
var slCon = _SLConnections.Find(c => c.Host == dconf["target"] && c.Username == dconf["username"]);
|
|
var pools = new List<CslgStoragePool>();
|
|
|
|
if (slCon != null)
|
|
{
|
|
pools = new List<StorageLinkPool>(slCon.Cache.StoragePools)
|
|
.FindAll(p => p.StorageLinkSystemId == _storageSystemId)
|
|
.ConvertAll(p => new CslgStoragePool(
|
|
p.FriendlyName,
|
|
p.opaque_ref,
|
|
GetRaidTypes(p.RaidTypes),
|
|
GetProvisioningTypes(p.ProvisioningTypes),
|
|
p.Parent != null,
|
|
p));
|
|
|
|
}
|
|
_cslgStoragePools = new ReadOnlyCollection<CslgStoragePool>(pools);
|
|
}
|
|
}
|
|
|
|
private static List<string> GetRaidTypes(StorageLinkEnums.RaidType raidType)
|
|
{
|
|
List<string> output = new List<string>();
|
|
foreach (StorageLinkEnums.RaidType r in Enum.GetValues(typeof(StorageLinkEnums.RaidType)))
|
|
{
|
|
if ((raidType & r) != 0)
|
|
{
|
|
output.Add(r.ToString());
|
|
}
|
|
}
|
|
|
|
if (output.Count == 0)
|
|
{
|
|
output.Add("RAID_NONE");
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
private static List<CslgParameter> GetProvisioningTypes(StorageLinkEnums.ProvisioningType provisioningType)
|
|
{
|
|
List<CslgParameter> output = new List<CslgParameter>();
|
|
if ((provisioningType & StorageLinkEnums.ProvisioningType.THICK) != 0)
|
|
{
|
|
output.Add(new CslgParameter("THICK", Messages.NEWSR_CSLG_THICK_PROVISIONING));
|
|
}
|
|
if ((provisioningType & StorageLinkEnums.ProvisioningType.THIN) != 0)
|
|
{
|
|
output.Add(new CslgParameter("THIN", Messages.NEWSR_CSLG_THIN_PROVISIONING));
|
|
}
|
|
return output;
|
|
}
|
|
}
|
|
|
|
#region CslgStoragePool class
|
|
|
|
/// <summary>
|
|
/// Represents of storoage pool on a storage system on a CSLG server.
|
|
/// </summary>
|
|
public class CslgStoragePool
|
|
{
|
|
private readonly string _displayName;
|
|
private readonly string _storagePoolId;
|
|
private readonly ReadOnlyCollection<string> _raidTypes;
|
|
private readonly ReadOnlyCollection<CslgParameter> _provisioningTypes;
|
|
private readonly bool _hasParent;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="CslgStoragePool"/> class.
|
|
/// </summary>
|
|
/// <param name="displayName">The display name.</param>
|
|
/// <param name="storagePoolId">The storage pool id.</param>
|
|
/// <param name="raidTypes">The raid types.</param>
|
|
/// <param name="provisioningTypes">The provisioning types.</param>
|
|
/// <param name="hasParent">if set to <c>true</c> if this pool has a parent pool.</param>
|
|
public CslgStoragePool(string displayName, string storagePoolId, IEnumerable<string> raidTypes, IEnumerable<CslgParameter> provisioningTypes, bool hasParent, StorageLinkPool storageLinkPool)
|
|
{
|
|
Util.ThrowIfStringParameterNullOrEmpty(displayName, "displayName");
|
|
Util.ThrowIfStringParameterNullOrEmpty(storagePoolId, "storagePoolId");
|
|
|
|
_displayName = displayName;
|
|
_storagePoolId = storagePoolId;
|
|
_raidTypes = new ReadOnlyCollection<string>(new List<string>(raidTypes));
|
|
_provisioningTypes = new ReadOnlyCollection<CslgParameter>(new List<CslgParameter>(provisioningTypes));
|
|
_hasParent = hasParent;
|
|
StorageLinkPool = storageLinkPool;
|
|
}
|
|
|
|
public StorageLinkPool StorageLinkPool { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets the available raid types for this pool.
|
|
/// </summary>
|
|
/// <value>The available raid types for this pool.</value>
|
|
public ReadOnlyCollection<string> RaidTypes
|
|
{
|
|
get
|
|
{
|
|
return _raidTypes;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the available provisioning types for this pool.
|
|
/// </summary>
|
|
/// <value>The available provisioning types for this pool.</value>
|
|
public ReadOnlyCollection<CslgParameter> ProvisioningTypes
|
|
{
|
|
get
|
|
{
|
|
return _provisioningTypes;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the storage pool id.
|
|
/// </summary>
|
|
/// <value>The storage pool id.</value>
|
|
public string StoragePoolId
|
|
{
|
|
get
|
|
{
|
|
return _storagePoolId;
|
|
}
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return _displayName;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a value indicating whether this pool has a parent pool.
|
|
/// </summary>
|
|
/// <value>
|
|
/// <c>true</c> if this instance has a parent pool; otherwise, <c>false</c>.
|
|
/// </value>
|
|
public bool HasParent
|
|
{
|
|
get { return _hasParent; }
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|