Esempio n. 1
0
 /// <summary>
 /// Creates a new Subject from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public Subject(Hashtable table)
 {
     uuid = Marshalling.ParseString(table, "uuid");
     subject_identifier = Marshalling.ParseString(table, "subject_identifier");
     other_config       = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     roles = Marshalling.ParseSetRef <Role>(table, "roles");
 }
Esempio n. 2
0
 /// <summary>
 /// Given a Hashtable with field-value pairs, it updates the fields of this USB_group
 /// with the values listed in the Hashtable. Note that only the fields contained
 /// in the Hashtable will be updated and the rest will remain the same.
 /// </summary>
 /// <param name="table"></param>
 public void UpdateFrom(Hashtable table)
 {
     if (table.ContainsKey("uuid"))
     {
         uuid = Marshalling.ParseString(table, "uuid");
     }
     if (table.ContainsKey("name_label"))
     {
         name_label = Marshalling.ParseString(table, "name_label");
     }
     if (table.ContainsKey("name_description"))
     {
         name_description = Marshalling.ParseString(table, "name_description");
     }
     if (table.ContainsKey("PUSBs"))
     {
         PUSBs = Marshalling.ParseSetRef <PUSB>(table, "PUSBs");
     }
     if (table.ContainsKey("VUSBs"))
     {
         VUSBs = Marshalling.ParseSetRef <VUSB>(table, "VUSBs");
     }
     if (table.ContainsKey("other_config"))
     {
         other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     }
 }
Esempio n. 3
0
 /// <summary>
 /// Given a Hashtable with field-value pairs, it updates the fields of this VM_appliance
 /// with the values listed in the Hashtable. Note that only the fields contained
 /// in the Hashtable will be updated and the rest will remain the same.
 /// </summary>
 /// <param name="table"></param>
 public void UpdateFrom(Hashtable table)
 {
     if (table.ContainsKey("uuid"))
     {
         uuid = Marshalling.ParseString(table, "uuid");
     }
     if (table.ContainsKey("name_label"))
     {
         name_label = Marshalling.ParseString(table, "name_label");
     }
     if (table.ContainsKey("name_description"))
     {
         name_description = Marshalling.ParseString(table, "name_description");
     }
     if (table.ContainsKey("allowed_operations"))
     {
         allowed_operations = Helper.StringArrayToEnumList <vm_appliance_operation>(Marshalling.ParseStringArray(table, "allowed_operations"));
     }
     if (table.ContainsKey("current_operations"))
     {
         current_operations = Maps.convert_from_proxy_string_vm_appliance_operation(Marshalling.ParseHashTable(table, "current_operations"));
     }
     if (table.ContainsKey("VMs"))
     {
         VMs = Marshalling.ParseSetRef <VM>(table, "VMs");
     }
 }
Esempio n. 4
0
 /// <summary>
 /// Creates a new Role from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public Role(Hashtable table)
 {
     uuid             = Marshalling.ParseString(table, "uuid");
     name_label       = Marshalling.ParseString(table, "name_label");
     name_description = Marshalling.ParseString(table, "name_description");
     subroles         = Marshalling.ParseSetRef <Role>(table, "subroles");
 }
Esempio n. 5
0
 /// <summary>
 /// Creates a new PIF from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public PIF(Hashtable table)
 {
     uuid                  = Marshalling.ParseString(table, "uuid");
     device                = Marshalling.ParseString(table, "device");
     network               = Marshalling.ParseRef <Network>(table, "network");
     host                  = Marshalling.ParseRef <Host>(table, "host");
     MAC                   = Marshalling.ParseString(table, "MAC");
     MTU                   = Marshalling.ParseLong(table, "MTU");
     VLAN                  = Marshalling.ParseLong(table, "VLAN");
     metrics               = Marshalling.ParseRef <PIF_metrics>(table, "metrics");
     physical              = Marshalling.ParseBool(table, "physical");
     currently_attached    = Marshalling.ParseBool(table, "currently_attached");
     ip_configuration_mode = (ip_configuration_mode)Helper.EnumParseDefault(typeof(ip_configuration_mode), Marshalling.ParseString(table, "ip_configuration_mode"));
     IP                      = Marshalling.ParseString(table, "IP");
     netmask                 = Marshalling.ParseString(table, "netmask");
     gateway                 = Marshalling.ParseString(table, "gateway");
     DNS                     = Marshalling.ParseString(table, "DNS");
     bond_slave_of           = Marshalling.ParseRef <Bond>(table, "bond_slave_of");
     bond_master_of          = Marshalling.ParseSetRef <Bond>(table, "bond_master_of");
     VLAN_master_of          = Marshalling.ParseRef <VLAN>(table, "VLAN_master_of");
     VLAN_slave_of           = Marshalling.ParseSetRef <VLAN>(table, "VLAN_slave_of");
     management              = Marshalling.ParseBool(table, "management");
     other_config            = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     disallow_unplug         = Marshalling.ParseBool(table, "disallow_unplug");
     tunnel_access_PIF_of    = Marshalling.ParseSetRef <Tunnel>(table, "tunnel_access_PIF_of");
     tunnel_transport_PIF_of = Marshalling.ParseSetRef <Tunnel>(table, "tunnel_transport_PIF_of");
     ipv6_configuration_mode = (ipv6_configuration_mode)Helper.EnumParseDefault(typeof(ipv6_configuration_mode), Marshalling.ParseString(table, "ipv6_configuration_mode"));
     IPv6                    = Marshalling.ParseStringArray(table, "IPv6");
     ipv6_gateway            = Marshalling.ParseString(table, "ipv6_gateway");
     primary_address_type    = (primary_address_type)Helper.EnumParseDefault(typeof(primary_address_type), Marshalling.ParseString(table, "primary_address_type"));
 }
Esempio n. 6
0
 /// <summary>
 /// Given a Hashtable with field-value pairs, it updates the fields of this Bond
 /// with the values listed in the Hashtable. Note that only the fields contained
 /// in the Hashtable will be updated and the rest will remain the same.
 /// </summary>
 /// <param name="table"></param>
 public void UpdateFrom(Hashtable table)
 {
     if (table.ContainsKey("uuid"))
     {
         uuid = Marshalling.ParseString(table, "uuid");
     }
     if (table.ContainsKey("master"))
     {
         master = Marshalling.ParseRef <PIF>(table, "master");
     }
     if (table.ContainsKey("slaves"))
     {
         slaves = Marshalling.ParseSetRef <PIF>(table, "slaves");
     }
     if (table.ContainsKey("other_config"))
     {
         other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     }
     if (table.ContainsKey("primary_slave"))
     {
         primary_slave = Marshalling.ParseRef <PIF>(table, "primary_slave");
     }
     if (table.ContainsKey("mode"))
     {
         mode = (bond_mode)Helper.EnumParseDefault(typeof(bond_mode), Marshalling.ParseString(table, "mode"));
     }
     if (table.ContainsKey("properties"))
     {
         properties = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "properties"));
     }
     if (table.ContainsKey("links_up"))
     {
         links_up = Marshalling.ParseLong(table, "links_up");
     }
 }
Esempio n. 7
0
 /// <summary>
 /// Given a Hashtable with field-value pairs, it updates the fields of this PVS_site
 /// with the values listed in the Hashtable. Note that only the fields contained
 /// in the Hashtable will be updated and the rest will remain the same.
 /// </summary>
 /// <param name="table"></param>
 public void UpdateFrom(Hashtable table)
 {
     if (table.ContainsKey("uuid"))
     {
         uuid = Marshalling.ParseString(table, "uuid");
     }
     if (table.ContainsKey("name_label"))
     {
         name_label = Marshalling.ParseString(table, "name_label");
     }
     if (table.ContainsKey("name_description"))
     {
         name_description = Marshalling.ParseString(table, "name_description");
     }
     if (table.ContainsKey("PVS_uuid"))
     {
         PVS_uuid = Marshalling.ParseString(table, "PVS_uuid");
     }
     if (table.ContainsKey("cache_storage"))
     {
         cache_storage = Marshalling.ParseSetRef <PVS_cache_storage>(table, "cache_storage");
     }
     if (table.ContainsKey("servers"))
     {
         servers = Marshalling.ParseSetRef <PVS_server>(table, "servers");
     }
     if (table.ContainsKey("proxies"))
     {
         proxies = Marshalling.ParseSetRef <PVS_proxy>(table, "proxies");
     }
 }
Esempio n. 8
0
 /// <summary>
 /// Creates a new USB_group from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public USB_group(Hashtable table)
 {
     uuid             = Marshalling.ParseString(table, "uuid");
     name_label       = Marshalling.ParseString(table, "name_label");
     name_description = Marshalling.ParseString(table, "name_description");
     PUSBs            = Marshalling.ParseSetRef <PUSB>(table, "PUSBs");
     VUSBs            = Marshalling.ParseSetRef <VUSB>(table, "VUSBs");
     other_config     = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
 }
Esempio n. 9
0
 /// <summary>
 /// Creates a new VM_appliance from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public VM_appliance(Hashtable table)
 {
     uuid               = Marshalling.ParseString(table, "uuid");
     name_label         = Marshalling.ParseString(table, "name_label");
     name_description   = Marshalling.ParseString(table, "name_description");
     allowed_operations = Helper.StringArrayToEnumList <vm_appliance_operation>(Marshalling.ParseStringArray(table, "allowed_operations"));
     current_operations = Maps.convert_from_proxy_string_vm_appliance_operation(Marshalling.ParseHashTable(table, "current_operations"));
     VMs = Marshalling.ParseSetRef <VM>(table, "VMs");
 }
Esempio n. 10
0
 /// <summary>
 /// Creates a new GPU_group from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public GPU_group(Hashtable table)
 {
     uuid             = Marshalling.ParseString(table, "uuid");
     name_label       = Marshalling.ParseString(table, "name_label");
     name_description = Marshalling.ParseString(table, "name_description");
     PGPUs            = Marshalling.ParseSetRef <PGPU>(table, "PGPUs");
     VGPUs            = Marshalling.ParseSetRef <VGPU>(table, "VGPUs");
     GPU_types        = Marshalling.ParseStringArray(table, "GPU_types");
     other_config     = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
 }
Esempio n. 11
0
 /// <summary>
 /// Creates a new PVS_site from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public PVS_site(Hashtable table)
 {
     uuid             = Marshalling.ParseString(table, "uuid");
     name_label       = Marshalling.ParseString(table, "name_label");
     name_description = Marshalling.ParseString(table, "name_description");
     PVS_uuid         = Marshalling.ParseString(table, "PVS_uuid");
     cache_storage    = Marshalling.ParseSetRef <PVS_cache_storage>(table, "cache_storage");
     servers          = Marshalling.ParseSetRef <PVS_server>(table, "servers");
     proxies          = Marshalling.ParseSetRef <PVS_proxy>(table, "proxies");
 }
Esempio n. 12
0
 /// <summary>
 /// Creates a new Bond from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public Bond(Hashtable table)
 {
     uuid          = Marshalling.ParseString(table, "uuid");
     master        = Marshalling.ParseRef <PIF>(table, "master");
     slaves        = Marshalling.ParseSetRef <PIF>(table, "slaves");
     other_config  = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     primary_slave = Marshalling.ParseRef <PIF>(table, "primary_slave");
     mode          = (bond_mode)Helper.EnumParseDefault(typeof(bond_mode), Marshalling.ParseString(table, "mode"));
     properties    = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "properties"));
     links_up      = Marshalling.ParseLong(table, "links_up");
 }
Esempio n. 13
0
 /// <summary>
 /// Creates a new PCI from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public PCI(Hashtable table)
 {
     uuid         = Marshalling.ParseString(table, "uuid");
     class_name   = Marshalling.ParseString(table, "class_name");
     vendor_name  = Marshalling.ParseString(table, "vendor_name");
     device_name  = Marshalling.ParseString(table, "device_name");
     host         = Marshalling.ParseRef <Host>(table, "host");
     pci_id       = Marshalling.ParseString(table, "pci_id");
     dependencies = Marshalling.ParseSetRef <PCI>(table, "dependencies");
     other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
 }
Esempio n. 14
0
 /// <summary>
 /// Given a Hashtable with field-value pairs, it updates the fields of this DR_task
 /// with the values listed in the Hashtable. Note that only the fields contained
 /// in the Hashtable will be updated and the rest will remain the same.
 /// </summary>
 /// <param name="table"></param>
 public void UpdateFrom(Hashtable table)
 {
     if (table.ContainsKey("uuid"))
     {
         uuid = Marshalling.ParseString(table, "uuid");
     }
     if (table.ContainsKey("introduced_SRs"))
     {
         introduced_SRs = Marshalling.ParseSetRef <SR>(table, "introduced_SRs");
     }
 }
Esempio n. 15
0
 /// <summary>
 /// Creates a new Pool_update from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public Pool_update(Hashtable table)
 {
     uuid              = Marshalling.ParseString(table, "uuid");
     name_label        = Marshalling.ParseString(table, "name_label");
     name_description  = Marshalling.ParseString(table, "name_description");
     installation_size = Marshalling.ParseLong(table, "installation_size");
     key = Marshalling.ParseString(table, "key");
     after_apply_guidance = Helper.StringArrayToEnumList <update_after_apply_guidance>(Marshalling.ParseStringArray(table, "after_apply_guidance"));
     vdi   = Marshalling.ParseRef <VDI>(table, "vdi");
     hosts = Marshalling.ParseSetRef <Host>(table, "hosts");
 }
Esempio n. 16
0
 /// <summary>
 /// Creates a new Pool_patch from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public Pool_patch(Hashtable table)
 {
     uuid                 = Marshalling.ParseString(table, "uuid");
     name_label           = Marshalling.ParseString(table, "name_label");
     name_description     = Marshalling.ParseString(table, "name_description");
     version              = Marshalling.ParseString(table, "version");
     size                 = Marshalling.ParseLong(table, "size");
     pool_applied         = Marshalling.ParseBool(table, "pool_applied");
     host_patches         = Marshalling.ParseSetRef <Host_patch>(table, "host_patches");
     after_apply_guidance = Helper.StringArrayToEnumList <after_apply_guidance>(Marshalling.ParseStringArray(table, "after_apply_guidance"));
     other_config         = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
 }
Esempio n. 17
0
 /// <summary>
 /// Creates a new PGPU from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public PGPU(Hashtable table)
 {
     uuid                          = Marshalling.ParseString(table, "uuid");
     PCI                           = Marshalling.ParseRef <PCI>(table, "PCI");
     GPU_group                     = Marshalling.ParseRef <GPU_group>(table, "GPU_group");
     host                          = Marshalling.ParseRef <Host>(table, "host");
     other_config                  = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     supported_VGPU_types          = Marshalling.ParseSetRef <VGPU_type>(table, "supported_VGPU_types");
     enabled_VGPU_types            = Marshalling.ParseSetRef <VGPU_type>(table, "enabled_VGPU_types");
     resident_VGPUs                = Marshalling.ParseSetRef <VGPU>(table, "resident_VGPUs");
     supported_VGPU_max_capacities = Maps.convert_from_proxy_XenRefVGPU_type_long(Marshalling.ParseHashTable(table, "supported_VGPU_max_capacities"));
 }
Esempio n. 18
0
 /// <summary>
 /// Creates a new GPU_group from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public GPU_group(Hashtable table)
 {
     uuid                 = Marshalling.ParseString(table, "uuid");
     name_label           = Marshalling.ParseString(table, "name_label");
     name_description     = Marshalling.ParseString(table, "name_description");
     PGPUs                = Marshalling.ParseSetRef <PGPU>(table, "PGPUs");
     VGPUs                = Marshalling.ParseSetRef <VGPU>(table, "VGPUs");
     GPU_types            = Marshalling.ParseStringArray(table, "GPU_types");
     other_config         = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     allocation_algorithm = (allocation_algorithm)Helper.EnumParseDefault(typeof(allocation_algorithm), Marshalling.ParseString(table, "allocation_algorithm"));
     supported_VGPU_types = Marshalling.ParseSetRef <VGPU_type>(table, "supported_VGPU_types");
     enabled_VGPU_types   = Marshalling.ParseSetRef <VGPU_type>(table, "enabled_VGPU_types");
 }
Esempio n. 19
0
 /// <summary>
 /// Creates a new VMSS from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public VMSS(Hashtable table)
 {
     uuid               = Marshalling.ParseString(table, "uuid");
     name_label         = Marshalling.ParseString(table, "name_label");
     name_description   = Marshalling.ParseString(table, "name_description");
     enabled            = Marshalling.ParseBool(table, "enabled");
     type               = (vmss_type)Helper.EnumParseDefault(typeof(vmss_type), Marshalling.ParseString(table, "type"));
     retained_snapshots = Marshalling.ParseLong(table, "retained_snapshots");
     frequency          = (vmss_frequency)Helper.EnumParseDefault(typeof(vmss_frequency), Marshalling.ParseString(table, "frequency"));
     schedule           = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "schedule"));
     last_run_time      = Marshalling.ParseDateTime(table, "last_run_time");
     VMs = Marshalling.ParseSetRef <VM>(table, "VMs");
 }
Esempio n. 20
0
 /// <summary>
 /// Given a Hashtable with field-value pairs, it updates the fields of this Cluster
 /// with the values listed in the Hashtable. Note that only the fields contained
 /// in the Hashtable will be updated and the rest will remain the same.
 /// </summary>
 /// <param name="table"></param>
 public void UpdateFrom(Hashtable table)
 {
     if (table.ContainsKey("uuid"))
     {
         uuid = Marshalling.ParseString(table, "uuid");
     }
     if (table.ContainsKey("cluster_hosts"))
     {
         cluster_hosts = Marshalling.ParseSetRef <Cluster_host>(table, "cluster_hosts");
     }
     if (table.ContainsKey("network"))
     {
         network = Marshalling.ParseRef <Network>(table, "network");
     }
     if (table.ContainsKey("cluster_token"))
     {
         cluster_token = Marshalling.ParseString(table, "cluster_token");
     }
     if (table.ContainsKey("cluster_stack"))
     {
         cluster_stack = Marshalling.ParseString(table, "cluster_stack");
     }
     if (table.ContainsKey("allowed_operations"))
     {
         allowed_operations = Helper.StringArrayToEnumList <cluster_operation>(Marshalling.ParseStringArray(table, "allowed_operations"));
     }
     if (table.ContainsKey("current_operations"))
     {
         current_operations = Maps.convert_from_proxy_string_cluster_operation(Marshalling.ParseHashTable(table, "current_operations"));
     }
     if (table.ContainsKey("pool_auto_join"))
     {
         pool_auto_join = Marshalling.ParseBool(table, "pool_auto_join");
     }
     if (table.ContainsKey("token_timeout"))
     {
         token_timeout = Marshalling.ParseLong(table, "token_timeout");
     }
     if (table.ContainsKey("token_timeout_coefficient"))
     {
         token_timeout_coefficient = Marshalling.ParseLong(table, "token_timeout_coefficient");
     }
     if (table.ContainsKey("cluster_config"))
     {
         cluster_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "cluster_config"));
     }
     if (table.ContainsKey("other_config"))
     {
         other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     }
 }
Esempio n. 21
0
 /// <summary>
 /// Given a Hashtable with field-value pairs, it updates the fields of this PGPU
 /// with the values listed in the Hashtable. Note that only the fields contained
 /// in the Hashtable will be updated and the rest will remain the same.
 /// </summary>
 /// <param name="table"></param>
 public void UpdateFrom(Hashtable table)
 {
     if (table.ContainsKey("uuid"))
     {
         uuid = Marshalling.ParseString(table, "uuid");
     }
     if (table.ContainsKey("PCI"))
     {
         PCI = Marshalling.ParseRef <PCI>(table, "PCI");
     }
     if (table.ContainsKey("GPU_group"))
     {
         GPU_group = Marshalling.ParseRef <GPU_group>(table, "GPU_group");
     }
     if (table.ContainsKey("host"))
     {
         host = Marshalling.ParseRef <Host>(table, "host");
     }
     if (table.ContainsKey("other_config"))
     {
         other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     }
     if (table.ContainsKey("supported_VGPU_types"))
     {
         supported_VGPU_types = Marshalling.ParseSetRef <VGPU_type>(table, "supported_VGPU_types");
     }
     if (table.ContainsKey("enabled_VGPU_types"))
     {
         enabled_VGPU_types = Marshalling.ParseSetRef <VGPU_type>(table, "enabled_VGPU_types");
     }
     if (table.ContainsKey("resident_VGPUs"))
     {
         resident_VGPUs = Marshalling.ParseSetRef <VGPU>(table, "resident_VGPUs");
     }
     if (table.ContainsKey("supported_VGPU_max_capacities"))
     {
         supported_VGPU_max_capacities = Maps.convert_from_proxy_XenRefVGPU_type_long(Marshalling.ParseHashTable(table, "supported_VGPU_max_capacities"));
     }
     if (table.ContainsKey("dom0_access"))
     {
         dom0_access = (pgpu_dom0_access)Helper.EnumParseDefault(typeof(pgpu_dom0_access), Marshalling.ParseString(table, "dom0_access"));
     }
     if (table.ContainsKey("is_system_display_device"))
     {
         is_system_display_device = Marshalling.ParseBool(table, "is_system_display_device");
     }
     if (table.ContainsKey("compatibility_metadata"))
     {
         compatibility_metadata = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "compatibility_metadata"));
     }
 }
Esempio n. 22
0
 /// <summary>
 /// Creates a new PGPU from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public PGPU(Hashtable table)
 {
     uuid                          = Marshalling.ParseString(table, "uuid");
     PCI                           = Marshalling.ParseRef <PCI>(table, "PCI");
     GPU_group                     = Marshalling.ParseRef <GPU_group>(table, "GPU_group");
     host                          = Marshalling.ParseRef <Host>(table, "host");
     other_config                  = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     supported_VGPU_types          = Marshalling.ParseSetRef <VGPU_type>(table, "supported_VGPU_types");
     enabled_VGPU_types            = Marshalling.ParseSetRef <VGPU_type>(table, "enabled_VGPU_types");
     resident_VGPUs                = Marshalling.ParseSetRef <VGPU>(table, "resident_VGPUs");
     supported_VGPU_max_capacities = Maps.convert_from_proxy_XenRefVGPU_type_long(Marshalling.ParseHashTable(table, "supported_VGPU_max_capacities"));
     dom0_access                   = (pgpu_dom0_access)Helper.EnumParseDefault(typeof(pgpu_dom0_access), Marshalling.ParseString(table, "dom0_access"));
     is_system_display_device      = Marshalling.ParseBool(table, "is_system_display_device");
 }
Esempio n. 23
0
 /// <summary>
 /// Creates a new Pool_update from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public Pool_update(Hashtable table)
 {
     uuid              = Marshalling.ParseString(table, "uuid");
     name_label        = Marshalling.ParseString(table, "name_label");
     name_description  = Marshalling.ParseString(table, "name_description");
     version           = Marshalling.ParseString(table, "version");
     installation_size = Marshalling.ParseLong(table, "installation_size");
     key = Marshalling.ParseString(table, "key");
     after_apply_guidance = Helper.StringArrayToEnumList <update_after_apply_guidance>(Marshalling.ParseStringArray(table, "after_apply_guidance"));
     vdi                 = Marshalling.ParseRef <VDI>(table, "vdi");
     hosts               = Marshalling.ParseSetRef <Host>(table, "hosts");
     other_config        = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     enforce_homogeneity = Marshalling.ParseBool(table, "enforce_homogeneity");
 }
Esempio n. 24
0
 /// <summary>
 /// Creates a new VGPU_type from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public VGPU_type(Hashtable table)
 {
     uuid                    = Marshalling.ParseString(table, "uuid");
     vendor_name             = Marshalling.ParseString(table, "vendor_name");
     model_name              = Marshalling.ParseString(table, "model_name");
     framebuffer_size        = Marshalling.ParseLong(table, "framebuffer_size");
     max_heads               = Marshalling.ParseLong(table, "max_heads");
     max_resolution_x        = Marshalling.ParseLong(table, "max_resolution_x");
     max_resolution_y        = Marshalling.ParseLong(table, "max_resolution_y");
     supported_on_PGPUs      = Marshalling.ParseSetRef <PGPU>(table, "supported_on_PGPUs");
     enabled_on_PGPUs        = Marshalling.ParseSetRef <PGPU>(table, "enabled_on_PGPUs");
     VGPUs                   = Marshalling.ParseSetRef <VGPU>(table, "VGPUs");
     supported_on_GPU_groups = Marshalling.ParseSetRef <GPU_group>(table, "supported_on_GPU_groups");
     enabled_on_GPU_groups   = Marshalling.ParseSetRef <GPU_group>(table, "enabled_on_GPU_groups");
 }
Esempio n. 25
0
 /// <summary>
 /// Creates a new Network from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public Network(Hashtable table)
 {
     uuid               = Marshalling.ParseString(table, "uuid");
     name_label         = Marshalling.ParseString(table, "name_label");
     name_description   = Marshalling.ParseString(table, "name_description");
     allowed_operations = Helper.StringArrayToEnumList <network_operations>(Marshalling.ParseStringArray(table, "allowed_operations"));
     current_operations = Maps.convert_from_proxy_string_network_operations(Marshalling.ParseHashTable(table, "current_operations"));
     VIFs               = Marshalling.ParseSetRef <VIF>(table, "VIFs");
     PIFs               = Marshalling.ParseSetRef <PIF>(table, "PIFs");
     MTU                  = Marshalling.ParseLong(table, "MTU");
     other_config         = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     bridge               = Marshalling.ParseString(table, "bridge");
     blobs                = Maps.convert_from_proxy_string_XenRefBlob(Marshalling.ParseHashTable(table, "blobs"));
     tags                 = Marshalling.ParseStringArray(table, "tags");
     default_locking_mode = (network_default_locking_mode)Helper.EnumParseDefault(typeof(network_default_locking_mode), Marshalling.ParseString(table, "default_locking_mode"));
 }
Esempio n. 26
0
 /// <summary>
 /// Given a Hashtable with field-value pairs, it updates the fields of this PCI
 /// with the values listed in the Hashtable. Note that only the fields contained
 /// in the Hashtable will be updated and the rest will remain the same.
 /// </summary>
 /// <param name="table"></param>
 public void UpdateFrom(Hashtable table)
 {
     if (table.ContainsKey("uuid"))
     {
         uuid = Marshalling.ParseString(table, "uuid");
     }
     if (table.ContainsKey("class_name"))
     {
         class_name = Marshalling.ParseString(table, "class_name");
     }
     if (table.ContainsKey("vendor_name"))
     {
         vendor_name = Marshalling.ParseString(table, "vendor_name");
     }
     if (table.ContainsKey("device_name"))
     {
         device_name = Marshalling.ParseString(table, "device_name");
     }
     if (table.ContainsKey("host"))
     {
         host = Marshalling.ParseRef <Host>(table, "host");
     }
     if (table.ContainsKey("pci_id"))
     {
         pci_id = Marshalling.ParseString(table, "pci_id");
     }
     if (table.ContainsKey("dependencies"))
     {
         dependencies = Marshalling.ParseSetRef <PCI>(table, "dependencies");
     }
     if (table.ContainsKey("other_config"))
     {
         other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     }
     if (table.ContainsKey("subsystem_vendor_name"))
     {
         subsystem_vendor_name = Marshalling.ParseString(table, "subsystem_vendor_name");
     }
     if (table.ContainsKey("subsystem_device_name"))
     {
         subsystem_device_name = Marshalling.ParseString(table, "subsystem_device_name");
     }
     if (table.ContainsKey("driver_name"))
     {
         driver_name = Marshalling.ParseString(table, "driver_name");
     }
 }
Esempio n. 27
0
 /// <summary>
 /// Given a Hashtable with field-value pairs, it updates the fields of this Pool_update
 /// with the values listed in the Hashtable. Note that only the fields contained
 /// in the Hashtable will be updated and the rest will remain the same.
 /// </summary>
 /// <param name="table"></param>
 public void UpdateFrom(Hashtable table)
 {
     if (table.ContainsKey("uuid"))
     {
         uuid = Marshalling.ParseString(table, "uuid");
     }
     if (table.ContainsKey("name_label"))
     {
         name_label = Marshalling.ParseString(table, "name_label");
     }
     if (table.ContainsKey("name_description"))
     {
         name_description = Marshalling.ParseString(table, "name_description");
     }
     if (table.ContainsKey("version"))
     {
         version = Marshalling.ParseString(table, "version");
     }
     if (table.ContainsKey("installation_size"))
     {
         installation_size = Marshalling.ParseLong(table, "installation_size");
     }
     if (table.ContainsKey("key"))
     {
         key = Marshalling.ParseString(table, "key");
     }
     if (table.ContainsKey("after_apply_guidance"))
     {
         after_apply_guidance = Helper.StringArrayToEnumList <update_after_apply_guidance>(Marshalling.ParseStringArray(table, "after_apply_guidance"));
     }
     if (table.ContainsKey("vdi"))
     {
         vdi = Marshalling.ParseRef <VDI>(table, "vdi");
     }
     if (table.ContainsKey("hosts"))
     {
         hosts = Marshalling.ParseSetRef <Host>(table, "hosts");
     }
     if (table.ContainsKey("other_config"))
     {
         other_config = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     }
     if (table.ContainsKey("enforce_homogeneity"))
     {
         enforce_homogeneity = Marshalling.ParseBool(table, "enforce_homogeneity");
     }
 }
Esempio n. 28
0
 /// <summary>
 /// Creates a new VGPU_type from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public VGPU_type(Hashtable table)
 {
     uuid                    = Marshalling.ParseString(table, "uuid");
     vendor_name             = Marshalling.ParseString(table, "vendor_name");
     model_name              = Marshalling.ParseString(table, "model_name");
     framebuffer_size        = Marshalling.ParseLong(table, "framebuffer_size");
     max_heads               = Marshalling.ParseLong(table, "max_heads");
     max_resolution_x        = Marshalling.ParseLong(table, "max_resolution_x");
     max_resolution_y        = Marshalling.ParseLong(table, "max_resolution_y");
     supported_on_PGPUs      = Marshalling.ParseSetRef <PGPU>(table, "supported_on_PGPUs");
     enabled_on_PGPUs        = Marshalling.ParseSetRef <PGPU>(table, "enabled_on_PGPUs");
     VGPUs                   = Marshalling.ParseSetRef <VGPU>(table, "VGPUs");
     supported_on_GPU_groups = Marshalling.ParseSetRef <GPU_group>(table, "supported_on_GPU_groups");
     enabled_on_GPU_groups   = Marshalling.ParseSetRef <GPU_group>(table, "enabled_on_GPU_groups");
     implementation          = (vgpu_type_implementation)Helper.EnumParseDefault(typeof(vgpu_type_implementation), Marshalling.ParseString(table, "implementation"));
     identifier              = Marshalling.ParseString(table, "identifier");
     experimental            = Marshalling.ParseBool(table, "experimental");
 }
Esempio n. 29
0
 /// <summary>
 /// Creates a new Task from a Hashtable.
 /// </summary>
 /// <param name="table"></param>
 public Task(Hashtable table)
 {
     uuid               = Marshalling.ParseString(table, "uuid");
     name_label         = Marshalling.ParseString(table, "name_label");
     name_description   = Marshalling.ParseString(table, "name_description");
     allowed_operations = Helper.StringArrayToEnumList <task_allowed_operations>(Marshalling.ParseStringArray(table, "allowed_operations"));
     current_operations = Maps.convert_from_proxy_string_task_allowed_operations(Marshalling.ParseHashTable(table, "current_operations"));
     created            = Marshalling.ParseDateTime(table, "created");
     finished           = Marshalling.ParseDateTime(table, "finished");
     status             = (task_status_type)Helper.EnumParseDefault(typeof(task_status_type), Marshalling.ParseString(table, "status"));
     resident_on        = Marshalling.ParseRef <Host>(table, "resident_on");
     progress           = Marshalling.ParseDouble(table, "progress");
     type               = Marshalling.ParseString(table, "type");
     result             = Marshalling.ParseString(table, "result");
     error_info         = Marshalling.ParseStringArray(table, "error_info");
     other_config       = Maps.convert_from_proxy_string_string(Marshalling.ParseHashTable(table, "other_config"));
     subtask_of         = Marshalling.ParseRef <Task>(table, "subtask_of");
     subtasks           = Marshalling.ParseSetRef <Task>(table, "subtasks");
 }
Esempio n. 30
0
 /// <summary>
 /// Given a Hashtable with field-value pairs, it updates the fields of this Role
 /// with the values listed in the Hashtable. Note that only the fields contained
 /// in the Hashtable will be updated and the rest will remain the same.
 /// </summary>
 /// <param name="table"></param>
 public void UpdateFrom(Hashtable table)
 {
     if (table.ContainsKey("uuid"))
     {
         uuid = Marshalling.ParseString(table, "uuid");
     }
     if (table.ContainsKey("name_label"))
     {
         name_label = Marshalling.ParseString(table, "name_label");
     }
     if (table.ContainsKey("name_description"))
     {
         name_description = Marshalling.ParseString(table, "name_description");
     }
     if (table.ContainsKey("subroles"))
     {
         subroles = Marshalling.ParseSetRef <Role>(table, "subroles");
     }
 }