mirror of
https://github.com/xcp-ng/xenadmin.git
synced 2024-12-20 23:46:03 +01:00
421 lines
14 KiB
C#
421 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;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Xml;
|
|
|
|
using XenAPI;
|
|
using Citrix.XenCenter;
|
|
using XenAdmin.Network;
|
|
|
|
namespace XenAdmin.ServerDBs
|
|
{
|
|
/// <summary>
|
|
/// A class which represents the XenServer status report Xml document. For use by <see cref="DbProxy"/>.
|
|
/// </summary>
|
|
public partial class Db
|
|
{
|
|
private readonly TableDictionary _tables;
|
|
private static readonly Dictionary<Type, Relation[]> AllRelations = Relation.GetRelations();
|
|
|
|
public Db(IXenConnection connection, string url)
|
|
{
|
|
_tables = new TableDictionary(this);
|
|
|
|
using (StreamReader stream = url.StartsWith("http") ? new StreamReader(HTTPHelper.GET(new Uri(url), connection, true, true)) : new StreamReader(url))
|
|
{
|
|
StatusReportXmlDocReader reader = new StatusReportXmlDocReader();
|
|
XmlDocument doc = new XmlDocument();
|
|
doc.XmlResolver = new BasicXMLResolver();
|
|
doc.Load(stream);
|
|
reader.PopulateDbFromXml(this, doc);
|
|
}
|
|
|
|
UpdateRelations();
|
|
|
|
_tables.Changed += TablesChanged;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
}
|
|
|
|
private bool disposed;
|
|
private void Dispose(bool disposing)
|
|
{
|
|
if(!disposed)
|
|
{
|
|
if(disposing)
|
|
{
|
|
_tables.Changed -= TablesChanged;
|
|
_tables.Clear();
|
|
disposed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void TablesChanged(object sender, EventArgs e)
|
|
{
|
|
_tables.Changed -= TablesChanged;
|
|
UpdateRelations();
|
|
_tables.Changed += TablesChanged;
|
|
}
|
|
|
|
public TableDictionary Tables
|
|
{
|
|
get
|
|
{
|
|
return _tables;
|
|
}
|
|
}
|
|
|
|
public object GetValue(string clazz, string opaque_ref, string field)
|
|
{
|
|
return Tables[clazz].Rows[opaque_ref].Props[field].XapiObjectValue;
|
|
}
|
|
|
|
public string ObjectWithFieldValue(string clazz, string field, string value)
|
|
{
|
|
foreach (KeyValuePair<string, Db.Row> row in Tables[clazz].Rows)
|
|
{
|
|
if (row.Value.Props[field].XapiObjectValue.ToString() == value)
|
|
{
|
|
return row.Key;
|
|
}
|
|
}
|
|
|
|
return Helper.NullOpaqueRef;
|
|
}
|
|
|
|
private void ClearRelations()
|
|
{
|
|
foreach (Table table in Tables.Values)
|
|
{
|
|
foreach (Db.Row row in table.Rows.Values)
|
|
{
|
|
Relation[] relations;
|
|
|
|
if (AllRelations.TryGetValue(table.XapiType, out relations))
|
|
{
|
|
foreach (Relation relation in relations)
|
|
{
|
|
row.Props[relation.field] = new Prop(row, relation.field, new string[0]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateRelations()
|
|
{
|
|
// clear all existing relation
|
|
ClearRelations();
|
|
|
|
foreach (PropInfo propInfo in GetAllPropsWithOpaqueRefValue())
|
|
{
|
|
foreach (KeyValuePair<Type, Relation[]> relationsPair in AllRelations)
|
|
{
|
|
foreach (Relation relation in relationsPair.Value)
|
|
{
|
|
if (relation.manyField.ToLower() == propInfo.Prop.Name.ToLower() && propInfo.Table.Name.ToLower() == relation.manyType.ToLower())
|
|
{
|
|
// string of the Proxy_ from the front.
|
|
string relTypeName = relationsPair.Key.Name.Substring(6);
|
|
|
|
if (Tables[relTypeName].Rows.ContainsKey(propInfo.PropValue))
|
|
{
|
|
List<string> list = new List<string>((string[])Tables[relTypeName].Rows[propInfo.PropValue].Props[relation.field].XapiObjectValue);
|
|
list.Add(propInfo.RowKey);
|
|
Tables[relTypeName].Rows[propInfo.PropValue].Props[relation.field].XapiObjectValue = list.ToArray();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private IEnumerable<PropInfo> GetAllPropsWithOpaqueRefValue()
|
|
{
|
|
foreach (Table table in Tables.Values)
|
|
{
|
|
foreach (KeyValuePair<string, Db.Row> row in table.Rows)
|
|
{
|
|
foreach (Prop prop in row.Value.Props.Values)
|
|
{
|
|
string propOpaqueRef = prop.XapiObjectValue as string;
|
|
|
|
if (propOpaqueRef != null && propOpaqueRef.StartsWith("OpaqueRef:") && propOpaqueRef != "OpaqueRef:NULL")
|
|
{
|
|
yield return new PropInfo(table, row.Key, row.Value, prop, propOpaqueRef);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private class PropInfo
|
|
{
|
|
public readonly Table Table;
|
|
public readonly string RowKey;
|
|
public readonly Row Row;
|
|
public readonly Prop Prop;
|
|
public readonly string PropValue;
|
|
|
|
public PropInfo(Table table, string rowKey, Row row, Prop prop, string propValue)
|
|
{
|
|
Table = table;
|
|
RowKey = rowKey;
|
|
Row = row;
|
|
Prop = prop;
|
|
PropValue = propValue;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A class which represents a table in the XenServer status report Xml document. For use by <see cref="DbProxy"/>.
|
|
/// </summary>
|
|
public class Table
|
|
{
|
|
private readonly string _name;
|
|
private readonly Type _xapiType;
|
|
private readonly RowDictionary _rows;
|
|
private readonly Db _db;
|
|
|
|
public event EventHandler Changed;
|
|
|
|
internal virtual void OnChanged(EventArgs e)
|
|
{
|
|
EventHandler handler = Changed;
|
|
|
|
if (handler != null)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="Table"/> class.
|
|
/// </summary>
|
|
/// <param name="name">The name of the table.</param>
|
|
/// <param name="db">The <see cref="Db"/> to which this <see cref="Table"/> is attached.</param>
|
|
public Table(string name, Db db)
|
|
{
|
|
Util.ThrowIfStringParameterNullOrEmpty(name, "name");
|
|
Util.ThrowIfParameterNull(db, "db");
|
|
|
|
_rows = new RowDictionary(this);
|
|
_name = name.ToLower();
|
|
_db = db;
|
|
_xapiType = TypeCache.GetProxyType(name);
|
|
|
|
_rows.Changed += delegate { OnChanged(EventArgs.Empty); };
|
|
}
|
|
|
|
public RowDictionary Rows
|
|
{
|
|
get
|
|
{
|
|
return _rows;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the name of this <see cref="Table"/>.
|
|
/// </summary>
|
|
/// <value>The name.</value>
|
|
public string Name
|
|
{
|
|
get { return _name; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the XAPI type that this <see cref="Table"/> represents.
|
|
/// </summary>
|
|
/// <value>The XAPI type that this <see cref="Table"/> represents.</value>
|
|
public Type XapiType
|
|
{
|
|
get { return _xapiType; }
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents a row entity in the parent <see cref="Table"/>.
|
|
/// </summary>
|
|
public class Row
|
|
{
|
|
private readonly PropDictionary _props;
|
|
private readonly Table _table;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="Row"/> class.
|
|
/// </summary>
|
|
/// <param name="table">The <see cref="Table"/> to which this <see cref="Row"/> belongs.</param>
|
|
public Row(Table table)
|
|
{
|
|
Util.ThrowIfParameterNull(table, "table");
|
|
|
|
_table = table;
|
|
_props = new PropDictionary(this);
|
|
_props.Changed += delegate { _table.OnChanged(EventArgs.Empty); };
|
|
}
|
|
|
|
public PropDictionary Props
|
|
{
|
|
get
|
|
{
|
|
return _props;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the <see cref="Table"/> which this <see cref="Row"/> belongs to.
|
|
/// </summary>
|
|
/// <value>The table.</value>
|
|
public Table Table
|
|
{
|
|
get { return _table; }
|
|
}
|
|
|
|
public Row CopyOf()
|
|
{
|
|
Row r = new Row(_table);
|
|
foreach (KeyValuePair<string, Prop> p in _props)
|
|
{
|
|
r.Props[p.Key] = p.Value.CopyOf(this);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
public void PopulateFrom(Hashtable h)
|
|
{
|
|
foreach (string key in h.Keys)
|
|
{
|
|
this.Props[key] = new Prop(this, key, h[key]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A class representing a property of a <see cref="Row"/> within the XenServer status report XML document.
|
|
/// </summary>
|
|
public class Prop
|
|
{
|
|
private readonly Row _row;
|
|
private Type _xapiType;
|
|
private readonly string _name;
|
|
private object _xapiValue;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="Prop"/> class.
|
|
/// </summary>
|
|
/// <param name="row">The row to which this <see cref="Prop"/> belongs.</param>
|
|
/// <param name="name">The name of this <see cref="Prop"/>.</param>
|
|
/// <param name="stringValue">The string value of this <see cref="Prop"/>.</param>
|
|
public Prop(Row row, string name, string stringValue)
|
|
{
|
|
Util.ThrowIfParameterNull(row, "row");
|
|
Util.ThrowIfStringParameterNullOrEmpty(name, "name");
|
|
Util.ThrowIfParameterNull(stringValue, "stringValue");
|
|
|
|
_row = row;
|
|
_name = name;
|
|
_xapiType = TypeCache.GetFieldType(_row.Table.Name, _name);
|
|
|
|
_xapiValue = Parser.Parse(XapiType, stringValue);
|
|
|
|
}
|
|
|
|
public Prop(Row row, string name, object xapiValue)
|
|
{
|
|
Util.ThrowIfParameterNull(row, "row");
|
|
Util.ThrowIfStringParameterNullOrEmpty(name, "name");
|
|
|
|
_row = row;
|
|
_name = name;
|
|
_xapiType = TypeCache.GetFieldType(_row.Table.Name, _name);
|
|
_xapiValue = xapiValue ?? Parser.Parse(XapiType, "");
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the name of this <see cref="Prop"/>.
|
|
/// </summary>
|
|
/// <value>The name.</value>
|
|
public string Name
|
|
{
|
|
get { return _name; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the XAPI type which this <see cref="Prop"/> represents.
|
|
/// </summary>
|
|
/// <value>The XAPI type which this <see cref="Prop"/> represents.</value>
|
|
public Type XapiType
|
|
{
|
|
get
|
|
{
|
|
return _xapiType;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the XAPI value which of the XAPI type which this <see cref="Prop"/> represents.
|
|
/// </summary>
|
|
/// <value>The xapi object value.</value>
|
|
public object XapiObjectValue
|
|
{
|
|
get
|
|
{
|
|
return _xapiValue;
|
|
}
|
|
set
|
|
{
|
|
Util.ThrowIfParameterNull(value, "value");
|
|
|
|
_xapiType = value.GetType();
|
|
_xapiValue = value;
|
|
|
|
_row.Table.OnChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
public Prop CopyOf(Row r)
|
|
{
|
|
return new Prop(r, _name, _xapiValue);
|
|
}
|
|
}
|
|
}
|
|
}
|