def _get_list_property(self, attribute):
"""
Getter for the list property
It will execute the related query every time to return a list of hybrid objects that
refer to this object. The resulting data will be stored or merged into the cached list
preserving as much already loaded objects as possible
"""
info = self._objects[attribute]['info']
remote_class = Descriptor().load(info['class']).get_object()
remote_key = info['key']
datalist = DataList.get_relation_set(remote_class, remote_key,
self.__class__, attribute,
self.guid)
if self._objects[attribute]['data'] is None:
self._objects[attribute]['data'] = DataObjectList(
datalist.data, remote_class)
else:
self._objects[attribute]['data'].update(datalist.data)
if info['list'] is True:
return self._objects[attribute]['data']
else:
data = self._objects[attribute]['data']
if len(data) > 1:
raise InvalidRelationException(
'More than one element found in {0}'.format(attribute))
return data[0] if len(data) == 1 else None
def test_dol_advanced(self):
"""
Validates the DataObjectList advanced functions (indexer, sort)
"""
sizes = [7, 2, 0, 4, 6, 1, 5, 9, 3, 8]
guids = []
for i in xrange(0, 10):
disk = TestDisk()
disk.name = 'disk_{0}'.format(i)
disk.size = sizes[i]
disk.save()
guids.append(disk.guid)
data = DataList({'object': TestDisk,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': []}}).data
disks = DataObjectList(data, TestDisk)
disks.sort()
guids.sort()
self.assertEqual(disks[0].guid, guids[0], 'Disks should be sorted on guid')
self.assertEqual(disks[4].guid, guids[4], 'Disks should be sorted on guid')
disks.sort(cmp=lambda a, b: a.size - b.size)
self.assertEqual(disks[0].size, 0, 'Disks should be sorted on size')
self.assertEqual(disks[4].size, 4, 'Disks should be sorted on size')
disks.sort(key=lambda a: a.name)
self.assertEqual(disks[0].name, 'disk_0', 'Disks should be sorted on name')
self.assertEqual(disks[4].name, 'disk_4', 'Disks should be sorted on name')
filtered = disks[1:4]
self.assertEqual(filtered[0].name, 'disk_1', 'Disks should be properly sliced')
self.assertEqual(filtered[2].name, 'disk_3', 'Disks should be properly sliced')
def get_mgmtcenters():
"""
Returns a list of MgmtCenters
"""
mgmtcenters = DataList({'object': MgmtCenter,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': []}}).data
return DataObjectList(mgmtcenters, MgmtCenter)
def get_vpools():
"""
Returns a list of all VPools
"""
vpools = DataList({'object': VPool,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': []}}).data
return DataObjectList(vpools, VPool)
def get_vmachines():
"""
Returns a list of all VMachines
"""
vmachines = DataList({'object': VMachine,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': []}}).data
return DataObjectList(vmachines, VMachine)
def get_partitions():
"""
Returns a list of all Partitions
"""
partitions = DataList({'object': DiskPartition,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': []}}).data
return DataObjectList(partitions, DiskPartition)
def get_vtemplates():
"""
Returns vTemplates
"""
vmachines = DataList({'object': VMachine,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': [('is_vtemplate', DataList.operator.EQUALS, True)]}}).data
return DataObjectList(vmachines, VMachine)
def get_storagedrivers():
"""
Returns a list of all StorageDrivers
"""
storagedrivers = DataList({'object': StorageDriver,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': []}}).data
return DataObjectList(storagedrivers, StorageDriver)
def get_storagedrivers_by_storagerouter(machineguid):
"""
Returns a list of all StorageDrivers for Storage Router
"""
storagedrivers = DataList({'object': StorageDriver,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': [('storagerouter_guid', DataList.operator.EQUALS, machineguid)]}}).data
return DataObjectList(storagedrivers, StorageDriver)
def get_disks():
"""
Returns a list of all Disks
"""
disks = DataList({'object': Disk,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': []}}).data
return DataObjectList(disks, Disk)
def get_services():
"""
Get all services of all types
"""
services = DataList({'object': Service,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': []}}).data
return DataObjectList(services, Service)
def list(self, query=None):
"""
Overview of all backend types
"""
if query is not None:
query = json.loads(query)
query_result = DataList({'object': BackendType,
'data': DataList.select.GUIDS,
'query': query}).data
return DataObjectList(query_result, BackendType)
return BackendTypeList.get_backend_types()
def get_by_ip(ip):
"""
Gets a mgmtCenter based on a given ip address
"""
mgmtcenters = DataList({'object': MgmtCenter,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': [('ip', DataList.operator.EQUALS, ip)]}}).data
if mgmtcenters:
return DataObjectList(mgmtcenters, MgmtCenter)[0]
return None
def get_by_ip(ip):
"""
Gets a pmachine based on a given ip address
"""
pmachines = DataList({'object': PMachine,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': [('ip', DataList.operator.EQUALS, ip)]}}).data
if pmachines:
return DataObjectList(pmachines, PMachine)[0]
return None
def list(self, query=None):
"""
Overview of all Storage Routers
"""
if query is None:
return StorageRouterList.get_storagerouters()
else:
query = json.loads(query)
query_result = DataList({'object': StorageRouter,
'data': DataList.select.GUIDS,
'query': query}).data
return DataObjectList(query_result, StorageRouter)
def get_ports_for_ip(ip):
"""
Returns a list of ports for all services on a given (StorageRouter) ip
"""
services = DataList({'object': Service,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': [('storagerouter.ip', DataList.operator.EQUALS, ip)]}}).data
ports = []
for service in DataObjectList(services, Service):
ports.extend(service.ports)
return list(set(ports))
def get_vmachine_by_name(vmname):
"""
Returns all VMachines which have a given name
"""
# pylint: disable=line-too-long
vmachines = DataList({'object': VMachine,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': [('name', DataList.operator.EQUALS, vmname)]}}).data # noqa
# pylint: enable=line-too-long
if vmachines:
return DataObjectList(vmachines, VMachine)
return None
def get_masters():
"""
Get all MASTER StorageRouters
"""
storagerouters = DataList({
'object': StorageRouter,
'data': DataList.select.GUIDS,
'query': {
'type': DataList.where_operator.AND,
'items': [('node_type', DataList.operator.EQUALS, 'MASTER')]
}
}).data
return DataObjectList(storagerouters, StorageRouter)
def get_by_storagedriver_id(storagedriver_id):
"""
Returns a list of all StorageDrivers based on a given storagedriver_id
"""
# pylint: disable=line-too-long
storagedrivers = DataList({'object': StorageDriver,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': [('storagedriver_id', DataList.operator.EQUALS, storagedriver_id)]}}).data
# pylint: enable=line-too-long
if storagedrivers:
return DataObjectList(storagedrivers, StorageDriver)[0]
return None
def get_vpool_by_name(vpool_name):
"""
Returns all VPools which have a given name
"""
vpools = DataList({'object': VPool,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': [('name', DataList.operator.EQUALS, vpool_name)]}}).data
if len(vpools) == 0:
return None
if len(vpools) == 1:
return DataObjectList(vpools, VPool)[0]
else:
raise RuntimeError('Only one vPool with name {0} should exist.'.format(vpool_name))
def _storagerouters_guids(self):
"""
Gets the StorageRouter guids linked to this vMachine
"""
storagerouter_guids = set()
from ovs.dal.hybrids.storagedriver import StorageDriver
storagedriver_ids = [vdisk.storagedriver_id for vdisk in self.vdisks if vdisk.storagedriver_id is not None]
storagedrivers = DataList({'object': StorageDriver,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': [('storagedriver_id', DataList.operator.IN, storagedriver_ids)]}}).data # noqa
for storagedriver in DataObjectList(storagedrivers, StorageDriver):
storagerouter_guids.add(storagedriver.storagerouter_guid)
return list(storagerouter_guids)
def get_by_devicename_and_vpool(devicename, vpool):
"""
Returns a list of all vMachines based on a given devicename and vpool
"""
vpool_guid = None if vpool is None else vpool.guid
vms = DataList({'object': VMachine,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': [('devicename', DataList.operator.EQUALS, devicename),
('vpool_guid', DataList.operator.EQUALS, vpool_guid)]}}).data
if vms:
if len(vms) != 1:
raise RuntimeError('Invalid amount of vMachines found: {0}'.format(len(vms)))
return DataObjectList(vms, VMachine)[0]
return None
def get_without_vmachine():
"""
Gets all vDisks without a vMachine
"""
# pylint: disable=line-too-long
vdisks = DataList({
'object': VDisk,
'data': DataList.select.GUIDS,
'query': {
'type': DataList.where_operator.AND,
'items': [('vmachine_guid', DataList.operator.EQUALS, None)]
}
}).data
# pylint: enable=line-too-long
return DataObjectList(vdisks, VDisk)
def _storagerouter_guid(self):
"""
Loads the vDisks StorageRouter guid
"""
if not self.storagedriver_id:
return None
from ovs.dal.hybrids.storagedriver import StorageDriver
storagedrivers = DataObjectList(
DataList({'object': StorageDriver,
'data': DataList.select.GUIDS,
'query': {'type': DataList.where_operator.AND,
'items': [('storagedriver_id', DataList.operator.EQUALS, self.storagedriver_id)]}}).data,
StorageDriver
)
if len(storagedrivers) == 1:
return storagedrivers[0].storagerouter_guid
return None
def get_by_parentsnapshot(snapshotid):
"""
Gets all vDisks whose parentsnapshot is snapshotid
"""
# pylint: disable=line-too-long
vdisks = DataList({
'object': VDisk,
'data': DataList.select.GUIDS,
'query': {
'type': DataList.where_operator.AND,
'items':
[('parentsnapshot', DataList.operator.EQUALS, snapshotid)]
}
}).data
# pylint: enable=line-too-long
return DataObjectList(vdisks, VDisk)
def get_vdisk_by_volume_id(volume_id):
"""
Returns a list of all VDisks based on a given volume id
"""
# pylint: disable=line-too-long
vdisks = DataList({
'object': VDisk,
'data': DataList.select.GUIDS,
'query': {
'type': DataList.where_operator.AND,
'items': [('volume_id', DataList.operator.EQUALS, volume_id)]
}
}).data
# pylint: enable=line-too-long
if vdisks:
return DataObjectList(vdisks, VDisk)[0]
return None
def get_vdisk_by_name(vdiskname):
"""
Returns all VDisks which have a given name
"""
# pylint: disable=line-too-long
vdisks = DataList({
'object': VDisk,
'data': DataList.select.GUIDS,
'query': {
'type': DataList.where_operator.AND,
'items': [('name', DataList.operator.EQUALS, vdiskname)]
}
}).data
# pylint: enable=line-too-long
if vdisks:
return DataObjectList(vdisks, VDisk)
return None
def get_by_ip(ip):
"""
Returns a StorageRouter by its ip
"""
storagerouters = DataList({
'object': StorageRouter,
'data': DataList.select.GUIDS,
'query': {
'type': DataList.where_operator.AND,
'items': [('ip', DataList.operator.EQUALS, ip)]
}
}).data
srs = DataObjectList(storagerouters, StorageRouter)
if len(srs) == 0:
return None
if len(srs) == 1:
return srs[0]
raise RuntimeError(
'There should be only one StorageRouter with ip: {0}'.format(ip))
def list(self, vpoolguid=None, query=None):
"""
Overview of all machines
"""
if vpoolguid is not None:
vpool = VPool(vpoolguid)
vmachine_guids = []
vmachines = []
for vdisk in vpool.vdisks:
if vdisk.vmachine_guid is not None and vdisk.vmachine_guid not in vmachine_guids:
vmachine_guids.append(vdisk.vmachine.guid)
if vdisk.vmachine.is_vtemplate is False:
vmachines.append(vdisk.vmachine)
elif query is not None:
query = json.loads(query)
query_result = DataList({'object': VMachine,
'data': DataList.select.GUIDS,
'query': query}).data
vmachines = DataObjectList(query_result, VMachine)
else:
vmachines = VMachineList.get_vmachines()
return vmachines
def get_by_devicename_and_vpool(devicename, vpool):
"""
Returns a list of all VDisks based on a given device name and vpool
"""
# pylint: disable=line-too-long
vds = DataList({
'object': VDisk,
'data': DataList.select.GUIDS,
'query': {
'type':
DataList.where_operator.AND,
'items': [('devicename', DataList.operator.EQUALS, devicename),
('vpool_guid', DataList.operator.EQUALS, vpool.guid)]
}
}).data # noqa
# pylint: enable=line-too-long
if vds:
if len(vds) != 1:
raise RuntimeError(
'Invalid amount of vDisks found: {0}'.format(len(vds)))
return DataObjectList(vds, VDisk)[0]
return None
def test_return_list(self):
"""
Validates whether the return_list decorator works correctly:
* Parsing:
* Parses the 'sort' parameter, optionally falling back to value specified by decorator
* Parses the 'page' parameter
* Parses the 'contents' parameter
* Passes the 'full' hint to the decorated function, indicating whether full objects are usefull
* If sorting is requested:
* Loads a possibly returned list of guids
* Sorts the returned list
* Contents:
* If contents are specified: Runs the list trough the serializer
* Else, return the guid list
"""
from backend.decorators import return_list
from ovs.dal.datalist import DataList
from ovs.dal.dataobjectlist import DataObjectList
@return_list(User)
def the_function_1(*args, **kwargs):
"""
Returns a list of all Users.
"""
output_values['args'] = args
output_values['kwargs'] = kwargs
return data_list_users
@return_list(User, default_sort='username,password')
def the_function_2(*args, **kwargs):
"""
Returns a guid list of all Users.
"""
output_values['args'] = args
output_values['kwargs'] = kwargs
return data_list_userguids
# Username/password combinations: [('bb', 'aa'), ('aa', 'cc'), ('bb', 'dd'), ('aa', 'bb')]
output_values = {}
users = DataList({
'object': User,
'data': DataList.select.GUIDS,
'query': {
'type':
DataList.where_operator.OR,
'items': [('username', DataList.operator.EQUALS, 'aa'),
('username', DataList.operator.EQUALS, 'bb')]
}
}).data
data_list_users = DataObjectList(users, User)
self.assertEqual(len(data_list_users), 4)
guid_table = {}
for user in data_list_users:
if user.username not in guid_table:
guid_table[user.username] = {}
guid_table[user.username][user.password] = user.guid
data_list_userguids = [user.guid for user in data_list_users]
request = Decorators.factory.get(
'/', HTTP_ACCEPT='application/json; version=1')
for function in [the_function_1, the_function_2]:
request.QUERY_PARAMS = {}
response = function(1, request)
self.assertEqual(response.status_code, 200)
self.assertEqual(output_values['kwargs']['hints']['full'],
function.__name__ == 'the_function_2')
self.assertEqual(len(response.data), len(data_list_users))
if function.__name__ == 'the_function_2':
self.assertListEqual(response.data, [
guid_table['aa']['bb'], guid_table['aa']['cc'],
guid_table['bb']['aa'], guid_table['bb']['dd']
])
request.QUERY_PARAMS['sort'] = 'username,-password'
response = function(2, request)
self.assertEqual(response.status_code, 200)
self.assertEqual(output_values['kwargs']['hints']['full'], True)
self.assertEqual(len(response.data), len(data_list_users))
self.assertListEqual(response.data, [
guid_table['aa']['cc'], guid_table['aa']['bb'],
guid_table['bb']['dd'], guid_table['bb']['aa']
])
request.QUERY_PARAMS['sort'] = '-username,-password'
response = function(3, request)
self.assertEqual(response.status_code, 200)
self.assertEqual(output_values['kwargs']['hints']['full'], True)
self.assertEqual(len(response.data), len(data_list_users))
self.assertListEqual(response.data, [
guid_table['bb']['dd'], guid_table['bb']['aa'],
guid_table['aa']['cc'], guid_table['aa']['bb']
])
request.QUERY_PARAMS['sort'] = 'password,username'
response = function(4, request)
self.assertEqual(response.status_code, 200)
self.assertEqual(output_values['kwargs']['hints']['full'], True)
self.assertEqual(len(response.data), len(data_list_users))
self.assertListEqual(response.data, [
guid_table['bb']['aa'], guid_table['aa']['bb'],
guid_table['aa']['cc'], guid_table['bb']['dd']
])
request.QUERY_PARAMS['contents'] = ''
response = function(5, request)
self.assertEqual(response.status_code, 200)
self.assertEqual(output_values['kwargs']['hints']['full'], True)
self.assertEqual(len(response.data), len(data_list_users))
if function.__name__ == 'the_function_1':
self.assertIsInstance(response.data['instance'],
DataObjectList)
self.assertIsInstance(response.data['instance'][0], User)
self.assertIn(response.data['instance'][0].username,
['aa', 'bb'])
else:
self.assertIsInstance(response.data['instance'], list)
self.assertIsInstance(response.data['instance'][0], User)
self.assertIn(response.data['instance'][0].username,
['aa', 'bb'])