def initialize_disks(node_guid, disks):
"""
Initializes 1 or multiple disks
:param node_guid: Guid of the node to which the disks belong
:type node_guid: str
:param disks: Disks to initialize (key: device_alias, value: amount of ASDs to deploy)
:type disks: dict
:return: Dict of all failures with as key the Diskname, and as value the error
:rtype: dict
"""
node = AlbaNode(node_guid)
try:
available_disks = node.client.get_disks()
except (requests.ConnectionError, requests.Timeout):
AlbaNodeController._logger.exception('Could not connect to node {0} to validate disks'.format(node.guid))
raise
failures = {}
added_disks = []
for device_alias, amount in disks.iteritems():
device_id = device_alias.split('/')[-1]
AlbaNodeController._logger.debug('Initializing disk {0} at node {1}'.format(device_alias, node.ip))
if device_id not in available_disks or available_disks[device_id]['available'] is False:
AlbaNodeController._logger.exception('Disk {0} not available on node {1}'.format(device_alias, node.ip))
failures[device_alias] = 'Disk unavailable'
else:
add_disk_result = node.client.add_disk(disk_id=device_id)
# Verify if an AlbaDisk with found aliases already exists (eg: When initialize individual and initialize all run at the same time)
exists = False
aliases = add_disk_result['aliases']
for alba_disk in node.disks:
if set(alba_disk.aliases).intersection(set(aliases)):
exists = True
break
if exists is True:
continue
disk = AlbaDisk()
disk.aliases = aliases
disk.alba_node = node
disk.save()
if add_disk_result['_success'] is False:
failures[device_alias] = add_disk_result['_error']
disk.delete()
else:
device_id = disk.aliases[0].split('/')[-1]
for _ in xrange(amount):
add_asd_result = node.client.add_asd(disk_id=device_id)
if add_asd_result['_success'] is False:
failures[device_alias] = add_asd_result['_error']
added_disks.extend(add_disk_result['aliases'])
if node.storagerouter is not None:
DiskController.sync_with_reality(storagerouter_guid=node.storagerouter_guid)
for disk in node.storagerouter.disks:
if set(disk.aliases).intersection(set(added_disks)):
partition = disk.partitions[0]
if DiskPartition.ROLES.BACKEND not in partition.roles:
partition.roles.append(DiskPartition.ROLES.BACKEND)
partition.save()
return failures
def build_service_structure(structure, previous_structure=None):
"""
Builds a service structure
Example:
structure = Helper.build_service_structure({
'alba_backends': [1],
'alba_nodes': [1]
})
"""
if previous_structure is None:
previous_structure = {}
backend_types = previous_structure.get('backend_types', {})
service_types = previous_structure.get('service_types', {})
alba_backends = previous_structure.get('alba_backends', {})
alba_nodes = previous_structure.get('alba_nodes', {})
alba_disks = previous_structure.get('alba_disks', {})
alba_osds = previous_structure.get('alba_osds', {})
if 1 not in backend_types:
backend_type = BackendType()
backend_type.code = 'alba'
backend_type.name = 'ALBA'
backend_type.save()
backend_types[1] = backend_type
if 1 not in service_types:
service_type = ServiceType()
service_type.name = 'AlbaManager'
service_type.save()
service_types[1] = service_type
for ab_id in structure.get('alba_backends', ()):
if ab_id not in alba_backends:
backend = Backend()
backend.name = 'backend_{0}'.format(ab_id)
backend.backend_type = backend_types[1]
backend.save()
alba_backend = AlbaBackend()
alba_backend.backend = backend
alba_backend.scaling = AlbaBackend.SCALINGS.LOCAL
alba_backend.save()
alba_backends[ab_id] = alba_backend
service = Service()
service.name = 'backend_{0}_abm'.format(ab_id)
service.type = service_types[1]
service.ports = []
service.save()
abm_service = ABMService()
abm_service.service = service
abm_service.alba_backend = alba_backend
abm_service.save()
for an_id in structure.get('alba_nodes', []):
if an_id not in alba_nodes:
alba_node = AlbaNode()
alba_node.ip = '10.1.0.{0}'.format(an_id)
alba_node.port = 8500
alba_node.username = str(an_id)
alba_node.password = str(an_id)
alba_node.node_id = 'node_{0}'.format(an_id)
alba_node.save()
alba_nodes[an_id] = alba_node
for ad_id, an_id in structure.get('alba_disks', ()):
if ad_id not in alba_disks:
alba_disk = AlbaDisk()
alba_disk.aliases = ['/dev/alba_disk_{0}'.format(ad_id)]
alba_disk.alba_node = alba_nodes[an_id]
alba_disk.save()
alba_disks[ad_id] = alba_disk
for ao_id, ad_id, ab_id in structure.get('alba_osds', ()):
if ao_id not in alba_osds:
osd = AlbaOSD()
osd.osd_id = 'alba_osd_{0}'.format(ao_id)
osd.osd_type = AlbaOSD.OSD_TYPES.ASD
osd.alba_backend = alba_backends[ab_id]
osd.alba_disk = alba_disks[ad_id]
osd.save()
alba_osds[ao_id] = osd
return {'backend_types': backend_types,
'service_types': service_types,
'alba_backends': alba_backends,
'alba_nodes': alba_nodes,
'alba_disks': alba_disks,
'alba_osds': alba_osds}
