/* * 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: * * 1) Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2) 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; namespace XenAPI { /// /// Describes the vusb device /// First published in Unreleased. /// public partial class VUSB : XenObject { public VUSB() { } public VUSB(string uuid, List allowed_operations, Dictionary current_operations, XenRef VM, XenRef USB_group, Dictionary other_config, XenRef attached) { this.uuid = uuid; this.allowed_operations = allowed_operations; this.current_operations = current_operations; this.VM = VM; this.USB_group = USB_group; this.other_config = other_config; this.attached = attached; } /// /// Creates a new VUSB from a Proxy_VUSB. /// /// public VUSB(Proxy_VUSB proxy) { this.UpdateFromProxy(proxy); } public override void UpdateFrom(VUSB update) { uuid = update.uuid; allowed_operations = update.allowed_operations; current_operations = update.current_operations; VM = update.VM; USB_group = update.USB_group; other_config = update.other_config; attached = update.attached; } internal void UpdateFromProxy(Proxy_VUSB proxy) { uuid = proxy.uuid == null ? null : (string)proxy.uuid; allowed_operations = proxy.allowed_operations == null ? null : Helper.StringArrayToEnumList(proxy.allowed_operations); current_operations = proxy.current_operations == null ? null : Maps.convert_from_proxy_string_vusb_operations(proxy.current_operations); VM = proxy.VM == null ? null : XenRef.Create(proxy.VM); USB_group = proxy.USB_group == null ? null : XenRef.Create(proxy.USB_group); other_config = proxy.other_config == null ? null : Maps.convert_from_proxy_string_string(proxy.other_config); attached = proxy.attached == null ? null : XenRef.Create(proxy.attached); } public Proxy_VUSB ToProxy() { Proxy_VUSB result_ = new Proxy_VUSB(); result_.uuid = uuid ?? ""; result_.allowed_operations = (allowed_operations != null) ? Helper.ObjectListToStringArray(allowed_operations) : new string[] {}; result_.current_operations = Maps.convert_to_proxy_string_vusb_operations(current_operations); result_.VM = VM ?? ""; result_.USB_group = USB_group ?? ""; result_.other_config = Maps.convert_to_proxy_string_string(other_config); result_.attached = attached ?? ""; return result_; } /// /// Creates a new VUSB from a Hashtable. /// /// public VUSB(Hashtable table) { uuid = Marshalling.ParseString(table, "uuid"); allowed_operations = Helper.StringArrayToEnumList(Marshalling.ParseStringArray(table, "allowed_operations")); current_operations = Maps.convert_from_proxy_string_vusb_operations(Marshalling.ParseHashTable(table, "current_operations")); VM = Marshalling.ParseRef(table, "VM"); USB_group = Marshalling.ParseRef(table, "USB_group"); other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config")); attached = Marshalling.ParseRef(table, "attached"); } public bool DeepEquals(VUSB other, bool ignoreCurrentOperations) { if (ReferenceEquals(null, other)) return false; if (ReferenceEquals(this, other)) return true; if (!ignoreCurrentOperations && !Helper.AreEqual2(this.current_operations, other.current_operations)) return false; return Helper.AreEqual2(this._uuid, other._uuid) && Helper.AreEqual2(this._allowed_operations, other._allowed_operations) && Helper.AreEqual2(this._VM, other._VM) && Helper.AreEqual2(this._USB_group, other._USB_group) && Helper.AreEqual2(this._other_config, other._other_config) && Helper.AreEqual2(this._attached, other._attached); } public override string SaveChanges(Session session, string opaqueRef, VUSB server) { if (opaqueRef == null) { System.Diagnostics.Debug.Assert(false, "Cannot create instances of this type on the server"); return ""; } else { if (!Helper.AreEqual2(_other_config, server._other_config)) { VUSB.set_other_config(session, opaqueRef, _other_config); } return null; } } /// /// Get a record containing the current state of the given VUSB. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static VUSB get_record(Session session, string _vusb) { return new VUSB((Proxy_VUSB)session.proxy.vusb_get_record(session.uuid, _vusb ?? "").parse()); } /// /// Get a reference to the VUSB instance with the specified UUID. /// First published in Unreleased. /// /// The session /// UUID of object to return public static XenRef get_by_uuid(Session session, string _uuid) { return XenRef.Create(session.proxy.vusb_get_by_uuid(session.uuid, _uuid ?? "").parse()); } /// /// Get the uuid field of the given VUSB. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static string get_uuid(Session session, string _vusb) { return (string)session.proxy.vusb_get_uuid(session.uuid, _vusb ?? "").parse(); } /// /// Get the allowed_operations field of the given VUSB. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static List get_allowed_operations(Session session, string _vusb) { return Helper.StringArrayToEnumList(session.proxy.vusb_get_allowed_operations(session.uuid, _vusb ?? "").parse()); } /// /// Get the current_operations field of the given VUSB. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static Dictionary get_current_operations(Session session, string _vusb) { return Maps.convert_from_proxy_string_vusb_operations(session.proxy.vusb_get_current_operations(session.uuid, _vusb ?? "").parse()); } /// /// Get the VM field of the given VUSB. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static XenRef get_VM(Session session, string _vusb) { return XenRef.Create(session.proxy.vusb_get_vm(session.uuid, _vusb ?? "").parse()); } /// /// Get the USB_group field of the given VUSB. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static XenRef get_USB_group(Session session, string _vusb) { return XenRef.Create(session.proxy.vusb_get_usb_group(session.uuid, _vusb ?? "").parse()); } /// /// Get the other_config field of the given VUSB. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static Dictionary get_other_config(Session session, string _vusb) { return Maps.convert_from_proxy_string_string(session.proxy.vusb_get_other_config(session.uuid, _vusb ?? "").parse()); } /// /// Get the attached field of the given VUSB. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static XenRef get_attached(Session session, string _vusb) { return XenRef.Create(session.proxy.vusb_get_attached(session.uuid, _vusb ?? "").parse()); } /// /// Set the other_config field of the given VUSB. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb /// New value to set public static void set_other_config(Session session, string _vusb, Dictionary _other_config) { session.proxy.vusb_set_other_config(session.uuid, _vusb ?? "", Maps.convert_to_proxy_string_string(_other_config)).parse(); } /// /// Add the given key-value pair to the other_config field of the given VUSB. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb /// Key to add /// Value to add public static void add_to_other_config(Session session, string _vusb, string _key, string _value) { session.proxy.vusb_add_to_other_config(session.uuid, _vusb ?? "", _key ?? "", _value ?? "").parse(); } /// /// Remove the given key and its corresponding value from the other_config field of the given VUSB. If the key is not in that Map, then do nothing. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb /// Key to remove public static void remove_from_other_config(Session session, string _vusb, string _key) { session.proxy.vusb_remove_from_other_config(session.uuid, _vusb ?? "", _key ?? "").parse(); } /// /// Create a new VUSB record in the database only /// First published in Unreleased. /// /// The session /// The VM /// /// public static XenRef create(Session session, string _vm, string _usb_group, Dictionary _other_config) { return XenRef.Create(session.proxy.vusb_create(session.uuid, _vm ?? "", _usb_group ?? "", Maps.convert_to_proxy_string_string(_other_config)).parse()); } /// /// Create a new VUSB record in the database only /// First published in Unreleased. /// /// The session /// The VM /// /// public static XenRef async_create(Session session, string _vm, string _usb_group, Dictionary _other_config) { return XenRef.Create(session.proxy.async_vusb_create(session.uuid, _vm ?? "", _usb_group ?? "", Maps.convert_to_proxy_string_string(_other_config)).parse()); } /// /// Unplug the vusb device from the vm. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static void unplug(Session session, string _vusb) { session.proxy.vusb_unplug(session.uuid, _vusb ?? "").parse(); } /// /// Unplug the vusb device from the vm. /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static XenRef async_unplug(Session session, string _vusb) { return XenRef.Create(session.proxy.async_vusb_unplug(session.uuid, _vusb ?? "").parse()); } /// /// Removes a VUSB record from the database /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static void destroy(Session session, string _vusb) { session.proxy.vusb_destroy(session.uuid, _vusb ?? "").parse(); } /// /// Removes a VUSB record from the database /// First published in Unreleased. /// /// The session /// The opaque_ref of the given vusb public static XenRef async_destroy(Session session, string _vusb) { return XenRef.Create(session.proxy.async_vusb_destroy(session.uuid, _vusb ?? "").parse()); } /// /// Return a list of all the VUSBs known to the system. /// First published in Unreleased. /// /// The session public static List> get_all(Session session) { return XenRef.Create(session.proxy.vusb_get_all(session.uuid).parse()); } /// /// Get all the VUSB Records at once, in a single XML RPC call /// First published in Unreleased. /// /// The session public static Dictionary, VUSB> get_all_records(Session session) { return XenRef.Create(session.proxy.vusb_get_all_records(session.uuid).parse()); } /// /// Unique identifier/object reference /// public virtual string uuid { get { return _uuid; } set { if (!Helper.AreEqual(value, _uuid)) { _uuid = value; Changed = true; NotifyPropertyChanged("uuid"); } } } private string _uuid; /// /// list of the operations allowed in this state. This list is advisory only and the server state may have changed by the time this field is read by a client. /// public virtual List allowed_operations { get { return _allowed_operations; } set { if (!Helper.AreEqual(value, _allowed_operations)) { _allowed_operations = value; Changed = true; NotifyPropertyChanged("allowed_operations"); } } } private List _allowed_operations; /// /// links each of the running tasks using this object (by reference) to a current_operation enum which describes the nature of the task. /// public virtual Dictionary current_operations { get { return _current_operations; } set { if (!Helper.AreEqual(value, _current_operations)) { _current_operations = value; Changed = true; NotifyPropertyChanged("current_operations"); } } } private Dictionary _current_operations; /// /// VM that owns the VUSB /// public virtual XenRef VM { get { return _VM; } set { if (!Helper.AreEqual(value, _VM)) { _VM = value; Changed = true; NotifyPropertyChanged("VM"); } } } private XenRef _VM; /// /// USB group used by the VUSB /// public virtual XenRef USB_group { get { return _USB_group; } set { if (!Helper.AreEqual(value, _USB_group)) { _USB_group = value; Changed = true; NotifyPropertyChanged("USB_group"); } } } private XenRef _USB_group; /// /// Additional configuration /// public virtual Dictionary other_config { get { return _other_config; } set { if (!Helper.AreEqual(value, _other_config)) { _other_config = value; Changed = true; NotifyPropertyChanged("other_config"); } } } private Dictionary _other_config; /// /// The PUSB on which this VUSB is running /// public virtual XenRef attached { get { return _attached; } set { if (!Helper.AreEqual(value, _attached)) { _attached = value; Changed = true; NotifyPropertyChanged("attached"); } } } private XenRef _attached; } }