def list_jobs(self, only_unfinished=False):
"""Returns a list of jobs from the job queue
:param only_unfinished: indicates whether only unfinished jobs should
be returned
:returns: a list of Job objects
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
filter_query = None
if only_unfinished:
filter_query = ('select * from DCIM_LifecycleJob '
'where Name != "CLEARALL" and '
'JobStatus != "Reboot Completed" and '
'JobStatus != "Completed" and '
'JobStatus != "Completed with Errors" and '
'JobStatus != "Failed"')
doc = self.client.enumerate(uris.DCIM_LifecycleJob,
filter_query=filter_query)
drac_jobs = utils.find_xml(doc, 'DCIM_LifecycleJob',
uris.DCIM_LifecycleJob, find_all=True)
return [self._parse_drac_job(drac_job) for drac_job in drac_jobs]
def parse(cls, nic_attr_xml):
"""Parses XML and creates NICEnumerableAttribute object"""
nic_attr = NICAttribute.parse(cls.namespace, nic_attr_xml)
possible_values = [attr.text for attr
in utils.find_xml(nic_attr_xml, 'PossibleValues',
cls.namespace, find_all=True)]
return cls(nic_attr.fqdd, nic_attr.name, nic_attr.current_value,
nic_attr.pending_value, nic_attr.read_only,
possible_values)
def parse(cls, bios_attr_xml):
"""Parses XML and creates BIOSEnumerableAttribute object"""
bios_attr = BIOSAttribute.parse(cls.namespace, bios_attr_xml)
possible_values = [attr.text for attr
in utils.find_xml(bios_attr_xml, 'PossibleValues',
cls.namespace, find_all=True)]
return cls(bios_attr.name, bios_attr.current_value,
bios_attr.pending_value, bios_attr.read_only,
possible_values)
def list_power_supply_units(self):
"""Returns the list of PSUs
:returns: a list of PSU objects
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
"""
doc = self.client.enumerate(uris.DCIM_PowerSupplyView)
psus = utils.find_xml(doc, 'DCIM_PowerSupplyView',
uris.DCIM_PowerSupplyView,
find_all=True)
return [self._parse_psus(psu) for psu in psus]
def list_boot_devices(self):
"""Returns the list of boot devices
:returns: a dictionary with the boot modes and the list of associated
BootDevice objects, ordered by the pending_assigned_sequence
property
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
doc = self.client.enumerate(uris.DCIM_BootSourceSetting)
drac_boot_devices = utils.find_xml(doc, 'DCIM_BootSourceSetting',
uris.DCIM_BootSourceSetting,
find_all=True)
try:
boot_devices = [self._parse_drac_boot_device(drac_boot_device)
for drac_boot_device in drac_boot_devices]
except AttributeError:
# DRAC 11g doesn't have the BootSourceType attribute on the
# DCIM_BootSourceSetting resource
controller_version = (
lifecycle_controller.LifecycleControllerManagement(
self.client).get_version())
if controller_version < LC_CONTROLLER_VERSION_12G:
boot_devices = [
self._parse_drac_boot_device_11g(drac_boot_device)
for drac_boot_device in drac_boot_devices]
else:
raise
# group devices by boot mode
boot_devices_per_mode = {device.boot_mode: []
for device in boot_devices}
for device in boot_devices:
boot_devices_per_mode[device.boot_mode].append(device)
# sort the device list by pending assigned seqeuence
for mode in boot_devices_per_mode.keys():
boot_devices_per_mode[mode].sort(
key=lambda device: device.pending_assigned_sequence)
return boot_devices_per_mode
def get_health_state(self):
"""Returns the current health state of the node
:returns: health state of the node, one of 'UNKNOWN', 'OK', 'DEGRADED/WARNING' or 'ERROR'
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
filter_query = ('select HealthState from '
'DCIM_ComputerSystem where Name="srv:system"')
doc = self.client.enumerate(uris.DCIM_ComputerSystem,
filter_query=filter_query)
health_state = utils.find_xml(doc, 'HealthState',
uris.DCIM_ComputerSystem)
return HEALTH_STATES[health_state.text]
def list_boot_modes(self):
"""Returns the list of boot modes
:returns: list of BootMode objects
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
doc = self.client.enumerate(uris.DCIM_BootConfigSetting)
drac_boot_modes = utils.find_xml(doc, 'DCIM_BootConfigSetting',
uris.DCIM_BootConfigSetting,
find_all=True)
return [self._parse_drac_boot_mode(drac_boot_mode)
for drac_boot_mode in drac_boot_modes]
def list_raid_controllers(self):
"""Returns the list of RAID controllers
:returns: a list of RAIDController objects
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
doc = self.client.enumerate(uris.DCIM_ControllerView)
drac_raid_controllers = utils.find_xml(doc, 'DCIM_ControllerView',
uris.DCIM_ControllerView,
find_all=True)
return [self._parse_drac_raid_controller(controller)
for controller in drac_raid_controllers]
def get_version(self):
"""Returns the Lifecycle controller version
:returns: Lifecycle controller version as a tuple of integers
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
filter_query = ('select LifecycleControllerVersion '
'from DCIM_SystemView')
doc = self.client.enumerate(uris.DCIM_SystemView,
filter_query=filter_query)
lc_version_str = utils.find_xml(doc, 'LifecycleControllerVersion',
uris.DCIM_SystemView).text
return tuple(map(int, (lc_version_str.split('.'))))
def list_physical_disks(self):
"""Returns the list of physical disks
:returns: a list of PhysicalDisk objects
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
doc = self.client.enumerate(uris.DCIM_PhysicalDiskView)
drac_physical_disks = utils.find_xml(doc, 'DCIM_PhysicalDiskView',
uris.DCIM_PhysicalDiskView,
find_all=True)
return [self._parse_drac_physical_disk(disk)
for disk in drac_physical_disks]
def list_nic_interfaces(self):
"""Returns the list of NIC interfaces
:returns: a list of NIC inteface objects
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
doc = self.client.enumerate(uris.DCIM_NICView)
drac_nic_interfaces = utils.find_xml(doc, 'DCIM_NICView',
uris.DCIM_NICView,
find_all=True)
return [self._parse_drac_nic_interfaces(interface)
for interface in drac_nic_interfaces]
def list_nic_interfaces(self):
"""Returns the list of NIC interfaces
:returns: a list of NIC inteface objects
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
doc = self.client.enumerate(uris.DCIM_NICView)
drac_nic_interfaces = utils.find_xml(doc,
'DCIM_NICView',
uris.DCIM_NICView,
find_all=True)
return [
self._parse_drac_nic_interfaces(interface)
for interface in drac_nic_interfaces
]
def list_raid_controllers(self):
"""Returns the list of RAID controllers
:returns: a list of RAIDController objects
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
doc = self.client.enumerate(uris.DCIM_ControllerView)
drac_raid_controllers = utils.find_xml(doc,
'DCIM_ControllerView',
uris.DCIM_ControllerView,
find_all=True)
return [
self._parse_drac_raid_controller(controller)
for controller in drac_raid_controllers
]
def list_physical_disks(self):
"""Returns the list of physical disks
:returns: a list of PhysicalDisk objects
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
doc = self.client.enumerate(uris.DCIM_PhysicalDiskView)
drac_physical_disks = utils.find_xml(doc,
'DCIM_PhysicalDiskView',
uris.DCIM_PhysicalDiskView,
find_all=True)
return [
self._parse_drac_physical_disk(disk)
for disk in drac_physical_disks
]
def get_job(self, job_id):
"""Returns a job from the job queue
:param job_id: id of the job
:returns: a Job object on successful query, None otherwise
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
filter_query = ('select * from DCIM_LifecycleJob where InstanceID="%s"'
% job_id)
doc = self.client.enumerate(uris.DCIM_LifecycleJob,
filter_query=filter_query)
drac_job = utils.find_xml(doc, 'DCIM_LifecycleJob',
uris.DCIM_LifecycleJob)
if drac_job is not None:
return self._parse_drac_job(drac_job)
def get_job(self, job_id):
"""Returns a job from the job queue
:param job_id: id of the job
:returns: a Job object on successful query, None otherwise
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
filter_query = (
'select * from DCIM_LifecycleJob where InstanceID="%s"' % job_id)
doc = self.client.enumerate(uris.DCIM_LifecycleJob,
filter_query=filter_query)
drac_job = utils.find_xml(doc, 'DCIM_LifecycleJob',
uris.DCIM_LifecycleJob)
if drac_job is not None:
return self._parse_drac_job(drac_job)
def get_power_state(self):
"""Returns the current power state of the node
:returns: power state of the node, one of 'POWER_ON', 'POWER_OFF' or
'REBOOT'
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
filter_query = ('select EnabledState from '
'DCIM_ComputerSystem where Name="srv:system"')
# filter_query = ('select EnabledState from '
# 'CIM_ComputerSystem')
# doc = self.client.enumerate(uris.CIM_ComputerSystem,
# filter_query=filter_query)
doc = self.client.enumerate(uris.DCIM_ComputerSystem,
filter_query=filter_query)
enabled_state = utils.find_xml(doc, 'EnabledState',
uris.DCIM_ComputerSystem)
return POWER_STATES[enabled_state.text]
def get_power_state(self):
"""Returns the current power state of the node
:returns: power state of the node, one of 'POWER_ON', 'POWER_OFF' or
'REBOOT'
:raises: WSManRequestFailure on request failures
:raises: WSManInvalidResponse when receiving invalid response
:raises: DRACOperationFailed on error reported back by the DRAC
interface
"""
filter_query = ('select EnabledState from '
'DCIM_ComputerSystem where Name="srv:system"')
# filter_query = ('select EnabledState from '
# 'CIM_ComputerSystem')
# doc = self.client.enumerate(uris.CIM_ComputerSystem,
# filter_query=filter_query)
doc = self.client.enumerate(uris.DCIM_ComputerSystem,
filter_query=filter_query)
enabled_state = utils.find_xml(doc, 'EnabledState',
uris.DCIM_ComputerSystem)
return POWER_STATES[enabled_state.text]