def on_add_node(self, nodeId, groupId, site_id, auth, def_manager):
op = constants.ATTACH
if not(nodeId or groupId):
return None
defn_list = []
errs = []
sync_manager = SyncDef()
defType = def_manager.getType()
sp_defns = DBSession.query(SPDefLink).filter_by(group_id=to_unicode(groupId))
if sp_defns:
for eachdefn in sp_defns:
defn = def_manager.get_defn(eachdefn.def_id)
if defn:
defn_list.append(defn)
status = to_unicode(constants.OUT_OF_SYNC)
details = None
sync_manager.add_node_defn(nodeId, defn.id, defType, status, details)
node = DBSession.query(ManagedNode).filter_by(id=nodeId).first()
if node:
update_status = True
try:
sync_manager.sync_node(defn_list, node, groupId, site_id, auth, defType, op, def_manager, update_status, errs)
except Exception as ex:
if errs:
if len(errs)>0:
LOGGER.error('Error in syncing definition while adding node: ' + to_str(errs))
def on_remove_node(self, nodeId, groupId, site_id, auth, def_manager, isTransfer=False, csep_id=None):
op = constants.DETACH
if not groupId:
return None
errs = []
sync_manager = SyncDef()
defType = def_manager.getType()
node = DBSession.query(ManagedNode).filter_by(id=nodeId).first()
if node:
defn_list = []
node_defns = DBSession.query(ServerDefLink).filter_by(server_id=nodeId, def_type=defType)
if node_defns:
for eachdefn in node_defns:
defn = def_manager.get_defn(eachdefn.def_id)
if defn:
defn_list.append(defn)
continue
try:
update_status = True
sync_manager.sync_node(defn_list, node, groupId, site_id, auth, defType, op, def_manager, update_status, errs)
except Exception as ex:
LOGGER.error('Error: ' + to_str(ex))
if errs:
if len(errs)>0:
LOGGER.error('Error in syncing definition while removing node: ' + to_str(errs))
if node_defns:
for eachdefn in node_defns:
defn = def_manager.get_defn(eachdefn.def_id)
if defn:
if defn.scope!=constants.SCOPE_S:
if eachdefn.status == constants.OUT_OF_SYNC:
LOGGER.error('WARNING: The definition status is OUT_OF_SYNC. Still the definition linking with the server is getting deleted. server_id=' + node.id + ', def_id=' + eachdefn.def_id + ', def_type=' + eachdefn.def_type + ', details=' + to_str(eachdefn.details))
DBSession.delete(eachdefn)
if defn.scope == constants.SCOPE_S and isTransfer == False:
DBSession.delete(defn)
self.update_node_defn(auth, nodeId, groupId, site_id, defn.id, defn.type, '', datetime.now(), '', defn.scope, defType, csep_id)
def __init__(self):
self.storage_manager = Basic.getStorageManager()
self.manager = Basic.getGridManager()
self.sync_manager = SyncDef()
class StorageService():
def __init__(self):
self.storage_manager = Basic.getStorageManager()
self.manager = Basic.getGridManager()
self.sync_manager = SyncDef()
def get_storage_types(self):
try:
storage_type_list = []
storage_dic={'Network File Storage (NFS)':constants.NFS,'Internet SCSI (iSCSI)':constants.iSCSI,'ATA Over Ethernet (AOE)':constants.AOE,'Clustered LVM (CLVM)':constants.LVM,'Common Internet File System (CIFS)':constants.CIFS,'Global File System (GFS2)':constants.GFS,'Oracle Cluster File System (OCFS2)':constants.OCFS,'Fibre Channel (FC)':constants.FC}
for storage_values in storage_dic.keys():
storage_dic_temp={}
storage_dic_temp['name']=storage_values
storage_dic_temp['value']=storage_dic[storage_values]
storage_type_list.append(storage_dic_temp)
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "'}")
return dict(success='true', rows=storage_type_list)
def get_vm_id_list(self, auth, node_entities, vm_id_list):
for eachnode in node_entities:
vms = auth.get_entities(constants.DOMAIN, parent=eachnode)
for eachvm in vms:
vm_id_list.append(eachvm.entity_id)
return vm_id_list
def get_vm_local_usage(self, vm_name):
local_usage = 0.0
if vm_name:
vm = DBSession.query(VM).filter_by(name=vm_name).first()
if vm:
vm_id = vm.id
vm_disks = DBSession.query(VMDisks).filter_by(vm_id=vm_id)
if vm_disks:
for each_vm_disk in vm_disks:
vm_storage_link = DBSession.query(VMStorageLinks).filter_by(vm_disk_id=each_vm_disk.id).first()
if not vm_storage_link:
local_usage += each_vm_disk.disk_size
return local_usage
def get_storage_usage(self, auth, site_id, group_id, scope, defn):
usage = 0
vm_id_list = []
if scope==constants.SCOPE_DC:
site_entity = auth.get_entity(site_id)
groups = auth.get_entities(constants.SERVER_POOL, parent=site_entity)
for eachgroup in groups:
nodes = auth.get_entities(constants.MANAGED_NODE, parent=eachgroup)
vm_id_list = self.get_vm_id_list(auth, nodes, vm_id_list)
if scope == constants.SCOPE_SP:
group_entity = auth.get_entity(group_id)
nodes = auth.get_entities(constants.MANAGED_NODE, parent=group_entity)
vm_id_list = self.get_vm_id_list(auth, nodes, vm_id_list)
storage_disks = DBSession.query(StorageDisks).filter_by(storage_id=defn.id)
if storage_disks:
for each_disk in storage_disks:
vm_storage_link = DBSession.query(VMStorageLinks).filter_by(storage_disk_id=each_disk.id).first()
if vm_storage_link:
vm_id = None
vm_disk = DBSession.query(VMDisks).filter_by(id=vm_storage_link.vm_disk_id).first()
if vm_disk:
vm_id = vm_disk.vm_id
for each_vm_id in vm_id_list:
if each_vm_id == vm_id:
usage += vm_disk.disk_size
return usage
#pass
def get_storage_def_list(self, auth, site_id, group_id, scope=None, op=None):
storage_list = []
try:
if site_id == 'data_center':
site = self.manager.getSiteByGroupId(group_id)
if site:
site_id = site.id
sds = self.storage_manager.get_sd_ids(site_id, group_id, to_unicode(constants.STORAGE), scope)
if sds:
for item in sds:
temp_sd_dic = {}
s_def = self.storage_manager.get_sd(item.def_id, site_id, group_id, to_unicode(constants.STORAGE))
associated = False
if s_def:
node_defn = DBSession.query(ServerDefLink).filter_by(def_id=s_def.id).first()
if node_defn:
associated = True
usage = ''
if scope == constants.SCOPE_DC:
ss = DBSession.query(Storage_Stats).filter_by(entity_id=site_id, storage_id=s_def.id).first()
if ss:
usage = ss.allocation_in_DC
elif scope == constants.SCOPE_SP:
ss = DBSession.query(Storage_Stats).filter_by(entity_id=group_id, storage_id=s_def.id).first()
if ss:
usage = ss.allocation_in_SP
str_group_list = None
group_defns = DBSession.query(SPDefLink).filter_by(def_id=s_def.id)
if group_defns:
for eachdefn in group_defns:
group = DBSession.query(ServerGroup).filter_by(id=eachdefn.group_id).first()
if group:
if str_group_list:
str_group_list = str_group_list + ', ' + group.name
else:
str_group_list = group.name
total = 0.0
ss = s_def.get_stats()
if ss:
total = ss.total_size
definition = self.get_defn(s_def)
temp_sd_dic['stats'] = ''
temp_sd_dic['name'] = s_def.name
temp_sd_dic['connection_props'] = s_def.connection_props
temp_sd_dic['type'] = s_def.type
temp_sd_dic['id'] = s_def.id
temp_sd_dic['creds'] = s_def.creds
temp_sd_dic['creds_required'] = s_def.creds_required
temp_sd_dic['size'] = total
temp_sd_dic['definition'] = definition
temp_sd_dic['description'] = s_def.description
if op:
if op == 'SP' or op == 'DC':
temp_sd_dic['status'] = item.status
else:
temp_sd_dic['status'] = ''
else:
temp_sd_dic['status'] = s_def.status
temp_sd_dic['scope'] = s_def.scope
temp_sd_dic['associated'] = associated
temp_sd_dic['serverpools'] = str_group_list
if not usage:
usage = 0
temp_sd_dic['usage'] = usage
storage_list.append(temp_sd_dic)
else:
LOGGER.info('Storage definition not found.')
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return dict(success=False, msg=to_str(ex).replace("'", ''), rows=storage_list)
return dict(success=True, rows=storage_list)
def get_dc_storage_def_list(self, auth, site_id, group_id):
storage_list = []
try:
if site_id == 'data_center':
site = self.manager.getSiteByGroupId(group_id)
if site:
site_id = site.id
defn_list = self.storage_manager.getSiteDefListToAssociate(site_id, group_id, to_unicode(constants.STORAGE))
if defn_list:
for s_def in defn_list:
temp_sd_dic = {}
if s_def:
total = 0.0
if s_def.get_stats():
objStats = s_def.get_stats()
if objStats:
total = objStats.total_size
definition = self.get_defn(s_def)
temp_sd_dic['stats'] = ''
temp_sd_dic['name'] = s_def.name
temp_sd_dic['connection_props'] = s_def.connection_props
temp_sd_dic['type'] = s_def.type
temp_sd_dic['id'] = s_def.id
temp_sd_dic['creds'] = s_def.creds
temp_sd_dic['creds_required'] = s_def.creds_required
temp_sd_dic['size'] = total
temp_sd_dic['definition'] = definition
temp_sd_dic['description'] = s_def.description
temp_sd_dic['status'] = s_def.status
temp_sd_dic['scope'] = s_def.scope
storage_list.append(temp_sd_dic)
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return dict(success=False, msg=to_str(ex).replace("'", ''), rows=storage_list)
return dict(success=True, rows=storage_list)
def get_server_storage_def_list(self, auth, node_id, op):
storage_list = []
try:
defn_list = self.sync_manager.get_server_defns(node_id, to_unicode(constants.STORAGE))
if defn_list:
for item in defn_list:
temp_sd_dic = {}
s_def = self.storage_manager.get_defn(item.def_id)
if s_def:
total = 0.0
if s_def.get_stats():
objStats = s_def.get_stats()
if objStats:
total = objStats.total_size
definition = self.get_defn(s_def)
temp_sd_dic['stats'] = ''
temp_sd_dic['name'] = s_def.name
temp_sd_dic['connection_props'] = s_def.connection_props
temp_sd_dic['type'] = s_def.type
temp_sd_dic['id'] = s_def.id
temp_sd_dic['creds'] = s_def.creds
temp_sd_dic['creds_required'] = s_def.creds_required
temp_sd_dic['size'] = total
temp_sd_dic['definition'] = definition
temp_sd_dic['description'] = s_def.description
if op:
if op == 'S':
temp_sd_dic['status'] = item.status
else:
temp_sd_dic['status'] = ''
else:
temp_sd_dic['status'] = ''
temp_sd_dic['scope'] = s_def.scope
storage_list.append(temp_sd_dic)
except Exception as ex:
LOGGER.error(to_str(ex).replace("'", ''))
raise ex
return storage_list
###############$$$$$$$$$$$
def add_storage_def_cli(self, auth, site_id, group_id, node_id, type, opts, op_level=None, sp_ids=None, added_manually=False):
storagename = opts['name']
storage = DBSession.query(StorageDef).filter(StorageDef.name == storagename).first()
if storage:
return {'success':False,'msg':'The storage with storagename '+ storagename+' already exists.'}
result = self.add_storage_def(auth, site_id, group_id, node_id, type, opts, op_level, sp_ids, added_manually)
if result == "{success: true,msg: 'Storage Added.'}":
return {'success':True,'msg':'The storage with storagename '+storagename+' added successfully.'}
return {'success':False,'msg':result}
def add_storage_def(self, auth, site_id, group_id, node_id, type, opts, op_level=None, sp_ids=None, added_manually=False, scan_result=None):
new_sd = self.get_valid_sd(type, opts, op_level, added_manually)
site = self.manager.getSite(site_id)
group = self.manager.getGroup(auth, group_id)
node = None
group_list = self.manager.getGroupList(auth, site_id)
try:
sdlist = self.storage_manager.get_sds(site_id, group_id)
for sd in sdlist:
if new_sd.name == sd.name:
raise Exception('Storage share with same name already exists.')
errs = []
errs = self.update_storage_def(auth, new_sd, None, None, None, site, group, op_level, True, sp_ids, errs, scan_result)
if errs:
if len(errs) > 0:
add_mode = True
self.sync_manager.remove_defn(new_sd, site, group, node, auth, to_unicode(constants.STORAGE), constants.DETACH, 'REMOVE_STORAGE_DEF', self.storage_manager, self.manager, add_mode, group_list, op_level)
return {'success':False,'msg':to_str(errs).replace("'",'')}
except Exception as ex:
print_traceback()
err_desc = to_str(ex).replace("'", '')
err_desc = err_desc.strip()
LOGGER.error(err_desc)
try:
add_mode = True
defn_temp = self.storage_manager.get_sd(new_sd.id, None, None, None)
if defn_temp:
self.sync_manager.remove_defn(defn_temp, site, group, node, auth, to_unicode(constants.STORAGE), constants.DETACH, 'REMOVE_STORAGE_DEF', self.storage_manager, self.manager, add_mode, group_list, op_level)
except Exception as ex1:
print_traceback()
LOGGER.error(to_str(ex1).replace("'", ''))
raise Exception(to_str(ex1))
if err_desc:
raise Exception(err_desc)
return "{success: false,msg: '" + err_desc + "'}"
return "{success: true,msg: 'Storage Added.'}"
def edit_storage_def(self, auth, storage_id, site_id, groupId, type, op_level, sp_ids, opts):
try:
site = self.manager.getSite(site_id)
group = self.manager.getGroup(auth, groupId)
new_name = opts.get('name')
new_desc = opts.get('description')
self.update_storage_def(auth, None, new_name, new_desc, storage_id, site, group, op_level, False, sp_ids)
self.SaveScanResult(storage_id, site_id)
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", '').strip(), "'}")
return "{success: true,msg: 'Storage Updated.'}"
def get_valid_sd(self, type, options, scope, added_manually=False):
creds_req = False
creds = {}
conn_options = {}
if type == constants.iSCSI:
creds_req = True
creds['username'] = options.get('username')
creds['password'] = options.get('password')
conn_options['server'] = options.get('portal')
conn_options['target'] = options.get('target')
conn_options['options'] = options.get('options')
conn_options['username'] = options.get('username')
conn_options['password'] = options.get('password')
if type == constants.NFS:
conn_options['server'] = options.get('server')
conn_options['share'] = options.get('share')
conn_options['mount_point'] = options.get('mount_point')
conn_options['mount_options'] = options.get('mount_options')
if type == constants.AOE:
conn_options['interface'] = options.get('interface')
if type == constants.LVM:
conn_options['volume_group'] = options.get('volume_group')
if type == constants.CIFS:
conn_options['server'] = options.get('server')
conn_options['windows_share'] = options.get('windows_share')
conn_options['mount_point'] = options.get('mount_point')
conn_options['windows_username'] = options.get('windows_username')
conn_options['windows_password'] = options.get('windows_password')
conn_options['domain'] = options.get('domain')
if type == constants.GFS:
conn_options['device'] = options.get('device')
conn_options['mount_point'] = options.get('mount_point')
if type == constants.OCFS:
conn_options['device'] = options.get('device')
conn_options['mount_point'] = options.get('mount_point')
if type == constants.FC:
conn_options['host_adapter'] = options.get('host_adapter')
conn_options['bus_channel'] = options.get('bus_channel')
conn_options['target'] = options.get('target')
conn_options['lun'] = options.get('lun')
conn_options['added_manually'] = added_manually
new_sd = StorageDef(None, to_unicode(options.get('name')), type, to_unicode(options.get('description')), conn_options, scope, creds_req)
if creds_req == True:
new_sd.set_creds(creds)
if options['total_cap']!='null':
options['total_cap'] = str(options.get('total_cap')).strip()
if options['total_cap']:
total_cap = str(options.get('total_cap'))
if not total_cap:
total_cap=0
return new_sd
def associate_defns(self, site_id, group_id, def_type, def_ids, auth, op_level=None):
error_desc = ''
site = self.manager.getSite(site_id)
group = self.manager.getGroup(auth, group_id)
group_list = self.manager.getGroupList(auth, site_id)
def_id_list = def_ids.split(',')
for def_id in def_id_list:
new_sd = DBSession.query(StorageDef).filter_by(id=def_id).first()
node = None
sp_ids = group_id
try:
self.sync_manager.add_defn(new_sd, site, group, node, auth, to_unicode(constants.STORAGE), constants.ATTACH, 'ADD_STORAGE_DEF', self.storage_manager, self.manager, op_level, sp_ids)
except Exception as ex:
error_desc = to_str(ex)
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
add_mode = True
try:
self.sync_manager.remove_defn(new_sd, site, group, node, auth, to_unicode(constants.STORAGE), constants.DETACH, 'REMOVE_STORAGE_DEF', self.storage_manager, self.manager, add_mode, group_list, op_level)
except Exception as ex1:
print_traceback()
LOGGER.error(to_str(ex1).replace("'", ''))
raise Exception(to_str(ex1))
if error_desc:
raise Exception(error_desc)
return {'success':True,'msg':'Storage Added'}
def update_storage_def(self, auth, new_sd, new_name, new_desc, storage_id, site, group, op_level, new=True, sp_ids=None, errs=None, scan_result=None):
if new==True:
if group:
group_defns = DBSession.query(SPDefLink).filter_by(group_id=group.id)
elif site:
group_defns = DBSession.query(DCDefLink).filter_by(site_id=site.id)
for group_defn in group_defns:
rowSDef = DBSession.query(StorageDef).filter_by(id=group_defn.def_id, name=new_name).first()
if rowSDef:
raise Exception('Storage definition with the same name already exists')
node = None
self.sync_manager.add_defn(new_sd, site, group, node, auth, to_unicode(constants.STORAGE), constants.ATTACH, 'ADD_STORAGE_DEF', self.storage_manager, self.manager, op_level, sp_ids, scan_result)
else:
if group:
group_defns = DBSession.query(SPDefLink).filter_by(group_id=group.id)
elif site:
group_defns = DBSession.query(DCDefLink).filter_by(site_id=site.id)
for group_defn in group_defns:
rowSDef = DBSession.query(StorageDef).filter_by(id=group_defn.def_id, name=new_name).first()
if rowSDef and rowSDef.id != storage_id:
raise Exception('Storage definition with the same name already exists')
defn = DBSession.query(StorageDef).filter_by(id=storage_id).first()
self.sync_manager.update_defn(defn, new_name, new_desc, site, group, auth, to_unicode(constants.STORAGE), constants.ATTACH, self.storage_manager, 'UPDATE_STORAGE_DEF', op_level, sp_ids, self.manager)
def storage_definition(self, storage):
storagedef = DBSession.query(StorageDef).filter(StorageDef.name == storage).first()
return storagedef
def remove_storage_def_cli(self, auth, storage, site_id, op_level, groupId=None):
storagedef = self.storage_definition(storage)
if storagedef:
storage_id = storagedef.id
result = self.remove_storage_def(auth, storage_id, site_id, groupId, op_level)
return result
return {'success':False,'msg':'The storage'+storage+'does not exists'}
def is_storage_allocated(self, storage_id):
returnVal = False
msg = 'NOT_IN_USE'
try:
returnVal = self.storage_manager.is_storage_allocated(storage_id)
if returnVal:
msg = 'IN_USE'
return "{success: true,msg: '" + msg + "'}"
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex))
return "{success: false,msg: '" + to_str(ex) + "'}"
def remove_storage_def(self, auth, storage_id, site_id, groupId, op_level=None):
try:
site = self.manager.getSite(site_id)
group = self.manager.getGroup(auth, groupId)
group_list = self.manager.getGroupList(auth, site_id)
sd_to_remove = self.storage_manager.get_sd(storage_id, site_id, groupId, to_unicode(constants.STORAGE))
node = None
add_mode = False
warning_msg = self.sync_manager.remove_defn(sd_to_remove, site, group, node, auth, to_unicode(constants.STORAGE), constants.DETACH, 'REMOVE_STORAGE_DEF', self.storage_manager, self.manager, add_mode, group_list, op_level)
if warning_msg:
return "{success: true,msg: '" + warning_msg + "'}"
return "{success: true,msg: 'Storage Removed'}"
except Exception as ex:
print_traceback()
err_desc = to_str(ex).replace("'", '')
err_desc = err_desc.strip()
LOGGER.error(to_str(err_desc))
return "{success: false,msg: '" + err_desc + "'}"
def rename_storage_def(self, auth, new_name, storage_id, groupId):
pass
def get_vm_linked_with_storage(self, storage_disk_id):
vm = None
if storage_disk_id:
vm_storage_link = DBSession.query(VMStorageLinks).filter_by(storage_disk_id=storage_disk_id).first()
if vm_storage_link:
vm_disk = DBSession.query(VMDisks).filter_by(id=vm_storage_link.vm_disk_id).first()
if vm_disk:
vm = DBSession.query(VM).filter_by(id=vm_disk.vm_id).first()
return vm
def edit_test_output(self, details):
objStat = {}
objSummary = {}
objDetailsList = []
objStorageDetails = {}
if details:
objSummary = details.get('SUMMARY')
objStorageDetails = details.get('STORAGE_DETAILS')
details_list = details.get('DETAILS')
for objDetails in details_list:
storage_disk_id = None
storage_allocated = False
vm_name = None
disk_name = None
if objDetails.get('uuid'):
unique_path = str(objDetails.get('uuid')).strip()
storage_disk = DBSession.query(StorageDisks).filter_by(unique_path=to_unicode(unique_path)).first()
storage_allocated = 'No'
if storage_disk:
if storage_disk.storage_allocated == True:
storage_allocated = 'Yes'
storage_disk_id = storage_disk.id
uuid_param = to_str(unique_path).split('/')
disk_name = uuid_param[len(uuid_param) - 1]
objDetails['STORAGE_ALLOCATED'] = storage_allocated
objDetails['DISKS'] = disk_name
if storage_disk_id:
vm = self.get_vm_linked_with_storage(storage_disk_id)
if vm:
vm_name = vm.name
objDetails['VM_NAME'] = vm_name
objDetailsList.append(objDetails)
objStat['STORAGE_DETAILS'] = objStorageDetails
objStat['DETAILS'] = objDetailsList
objStat['SUMMARY'] = objSummary
return objStat
def get_storage_for_test(self, storage_id):
objStat = {}
objSummary = {}
objDetailsList = []
objDetails = {}
objStorageDetails = {}
disk_name = None
storage_type = None
total_size = 0
available_size = 0
if storage_id:
defn = self.storage_manager.get_defn(storage_id)
if defn:
stats = defn.get_stats()
if stats:
total_size = stats.total_size
objStorageDetails = []
storage_disks = DBSession.query(StorageDisks).filter_by(storage_id=defn.id)
for each_storage_disk in storage_disks:
if objDetails:
objDetailsList.append(objDetails)
objDetails = {}
objDetails['STORAGE_DISK_ID'] = None
objDetails['STORAGE_ALLOCATED'] = False
objDetails['USED'] = each_storage_disk.size
objDetails['SIZE'] = each_storage_disk.actual_size
objDetails['CurrentPortal'] = None
objDetails['Target'] = None
objDetails['uuid'] = each_storage_disk.unique_path
objDetails['State'] = None
objDetails['Lun'] = None
objDetails['VM_NAME'] = None
objStat['name'] = defn.name
objStat['success'] = True
objStat['type'] = defn.type
objStat['id'] = defn.id
objStat['op'] = constants.GET_DISKS
if objStorageDetails:
objStat['STORAGE_DETAILS'] = objStorageDetails
if objDetails:
objDetailsList.append(objDetails)
objStat['DETAILS'] = objDetailsList
if objSummary:
objStat['SUMMARY'] = objSummary
return objStat
#############################################pas
def get_storage_disks_for_test(self, storage_id, show_available, vm_config_action, disk_option):
objStat = {}
objSummary = {}
objDetailsList = []
objDetails = {}
objStorageDetails = []
disk_name = None
storage_type = None
total_size = 0
available_size = 0
vm_name = None
storage_disks = None
if vm_config_action == 'provision_vm' or vm_config_action == 'provision_image' or vm_config_action == 'edit_image':
if disk_option == 'CREATE_DISK':
objStat = self.get_storage_for_test(storage_id)
return objStat
if show_available == 'true':
storage_disks = DBSession.query(StorageDisks).filter_by(storage_id=storage_id, storage_allocated=False)
else:
storage_disks = DBSession.query(StorageDisks).filter_by(storage_id=storage_id)
if storage_id:
defn = self.storage_manager.get_defn(storage_id)
if defn:
stats = defn.get_stats()
if stats:
total_size = stats.total_size
objSummary['TOTAL'] = total_size
storage_detail = {}
storage_detail['AVAILABLE'] = stats.available_size
storage_detail['USED'] = stats.used_size
storage_detail['SIZE'] = stats.total_size
storage_detail['MOUNT'] = ''
storage_detail['FILESYSTEM'] = ''
storage_detail['VOLUME_GROUP'] = ''
storage_detail['uuid'] = ''
objStorageDetails.append(storage_detail)
if storage_disks:
for each_storage_disk in storage_disks:
if objDetails:
objDetailsList.append(objDetails)
objDetails = {}
disk_name = each_storage_disk.disk_name
storage_type = each_storage_disk.storage_type
storage_id = each_storage_disk.storage_id
objDetails['STORAGE_DISK_ID'] = each_storage_disk.id
if each_storage_disk.storage_allocated == True:
objDetails['STORAGE_ALLOCATED'] = 'Yes'
else:
objDetails['STORAGE_ALLOCATED'] = 'No'
objDetails['USED'] = each_storage_disk.size
objDetails['SIZE'] = each_storage_disk.actual_size
objDetails['CurrentPortal'] = each_storage_disk.current_portal
objDetails['Target'] = each_storage_disk.target
objDetails['uuid'] = each_storage_disk.unique_path
objDetails['State'] = each_storage_disk.state
objDetails['Lun'] = each_storage_disk.lun
vm_name = None
vm = self.get_vm_linked_with_storage(each_storage_disk.id)
if vm:
vm_name = vm.name
objDetails['VM_NAME'] = vm_name
disk_name = None
unique_path = each_storage_disk.unique_path
if unique_path:
uuid_param = to_str(unique_path).split('/')
disk_name = uuid_param[len(uuid_param) - 1]
objDetails['DISKS'] = disk_name
logical_volume = None
disk_param = []
disk_param = to_str(each_storage_disk.unique_path).split('/')
if disk_param:
logical_volume = disk_param[len(disk_param) - 1]
objDetails['LOGICAL_VOLUME'] = logical_volume
objStat['name'] = defn.name
objStat['success'] = True
objStat['type'] = storage_type
objStat['id'] = storage_id
objStat['op'] = constants.GET_DISKS
if objStorageDetails:
objStat['STORAGE_DETAILS'] = objStorageDetails
if objDetails:
objDetailsList.append(objDetails)
objStat['DETAILS'] = objDetailsList
if objSummary:
objStat['SUMMARY'] = objSummary
return objStat
def storage_def_test_cli(self, auth, storage_name, nodeId, groupId, site_id, type, mode, opts, scope, show_available='true', vm_config_action=None, disk_option=None):
storagedef = DBSession.query(StorageDef).filter(StorageDef.name == storage_name).first()
if storagedef:
storage_id = storagedef.id
result = self.storage_def_test(auth, storage_id, nodeId, groupId, site_id, type, mode, opts, scope, show_available, vm_config_action, disk_option)
return result
return dict(success=False, msg='The storage ' + storage_name + ' does not exists')
###########################pas
def storage_def_test(self, auth, storage_id, nodeId, groupId, site_id, type, mode, opts, scope, show_available='true', vm_config_action=None, disk_option=None):
if mode == 'SELECT':
result = self.get_storage_disks_for_test(storage_id, show_available, vm_config_action, disk_option)
return result
try:
self.storage_manager.RemoveScanResult()
group = self.manager.getGroup(auth, groupId)
managed_node = self.manager.getNode(auth, nodeId)
if not managed_node:
raise Exception('Managed Server not found.')
try:
managed_node.connect()
except AuthenticationException as ex:
if opts.has_key('username') and opts.has_key('password'):
managed_node.set_credentials(opts['username'], opts['password'])
try:
managed_node.connect()
except AuthenticationException as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "',error:'Not Authenticated'}")
else:
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "',error:'Not Authenticated'}")
sd = None
if mode == 'TEST' or mode == 'EDIT' or mode == 'SELECT':
sd = self.storage_manager.get_sd(storage_id, site_id, groupId, to_unicode(constants.STORAGE))
else:
sd = self.get_valid_sd(type, opts, scope)
if site_id:
if site_id == 'data_center':
site = self.manager.getSiteByGroupId(group.id)
else:
site = self.manager.getSite(site_id)
else:
site = self.manager.getSiteByGroupId(group.id)
result = self.test_storage_def(auth, managed_node, group, site, sd)
if result or mode == 'NEW' or mode == 'EDIT':
#if not mode == 'NEW' or mode == 'EDIT':
try:
session[constants.SCAN_RESULT] = result
session.save()
except Exception as ex:
print_traceback()
LOGGER.error('Error while keeping the scan result in session: ' + to_str(ex).replace("'", ''))
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return dict(success=False, msg=to_str(ex).replace("'", ''))
return result
def test_storage_def(self, auth, managed_node, group, site, sd):
details = None
testmsg = None
try:
details = self.storage_manager.get_sd_details(auth, sd, managed_node, group, site, to_unicode(constants.STORAGE), self.storage_manager)
details = self.edit_test_output(details)
except Exception as ex:
testmsg = ex
if details == None or len(details) == 0 or testmsg != None:
if testmsg:
LOGGER.info(to_str(testmsg).replace("'", ''))
else:
testmsg = ''
return dict(success=False, msg=to_str(testmsg).replace("'", ''))
details['success'] = 'true'
return details
def get_defn(self, sd):
if not sd:
return ''
desc = None
if sd.type == constants.NFS:
desc = sd.connection_props['server'] + ', ' + sd.connection_props['share']
elif sd.type == constants.iSCSI:
desc = sd.connection_props['server'] + ', ' + sd.connection_props['target']
elif sd.type == constants.AOE:
desc = sd.connection_props['interface']
if not desc:
return ''
return desc
###################
def get_server_def_list(self, auth, site_id, group_id, def_id):
try:
server_def_list = []
node_defns = self.sync_manager.get_node_defns(def_id, to_unicode(constants.STORAGE))
if node_defns:
for eachdefn in node_defns:
temp_dic = {}
if eachdefn:
node = DBSession.query(ManagedNode).filter_by(id=eachdefn.server_id).first()
node_entity = auth.get_entity(node.id)
if group_id:
if group_id == node_entity.parents[0].entity_id:
temp_dic['id'] = eachdefn.server_id
if node:
temp_dic['name'] = node.hostname
temp_dic['serverpool'] = node_entity.parents[0].name
else:
temp_dic['name'] = None
temp_dic['serverpool'] = None
temp_dic['status'] = eachdefn.status
if eachdefn.details:
temp_dic['details'] = eachdefn.details
else:
temp_dic['details'] = None
server_def_list.append(temp_dic)
else:
temp_dic['id'] = eachdefn.server_id
if node:
temp_dic['name'] = node.hostname
temp_dic['serverpool'] = node_entity.parents[0].name
else:
temp_dic['name'] = None
temp_dic['serverpool'] = None
temp_dic['status'] = eachdefn.status
if eachdefn.details:
temp_dic['details'] = eachdefn.details
else:
temp_dic['details'] = None
server_def_list.append(temp_dic)
except Exception as ex:
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "'}")
return dict(success='true', rows=server_def_list)
def sync_defn(self, auth, server_ids, def_id, site_id, group_id):
server_id_list = server_ids.split(',')
for server_id in server_id_list:
node = DBSession.query(ManagedNode).filter_by(id=server_id).first()
defn = DBSession.query(StorageDef).filter_by(id=def_id).first()
self.sync_manager.sync_node_defn(auth, node, group_id, site_id, defn, constants.STORAGE, constants.ATTACH, self.storage_manager)
return dict(success='true')
def get_total_storage(self, auth, site_id, group_id, scope=None):
try:
result = self.get_storage_def_list(auth, site_id, group_id, scope)
total_storage = 0.0
stge_res = result.get('rows')
for val in stge_res:
if val.get('size'):
total_storage = total_storage + float(val.get('size'))
return total_storage
except Exception as ex:
LOGGER.error(to_str(ex).replace("'", ''))
raise ex
def update_disks_size(self, auth):
from stackone.model.availability import AvailState
sites = DBSession.query(Site)
if sites:
for eachsite in sites:
site_entity = auth.get_entity(eachsite.id)
group_entities = auth.get_entities(to_unicode(constants.SERVER_POOL), site_entity)
for eachgroup in group_entities:
group = DBSession.query(ServerGroup).filter_by(id=eachgroup.entity_id).first()
if group:
group_entity = auth.get_entity(group.id)
node_entities = auth.get_entities(to_unicode(constants.MANAGED_NODE), group_entity)
for eachnode in node_entities:
node = DBSession.query(ManagedNode).filter_by(id=eachnode.entity_id).first()
is_node_up = True
objAvailState = DBSession.query(AvailState).filter_by(entity_id=node.id).first()
if objAvailState:
avail_state = objAvailState.avail_state
if avail_state == node.DOWN:
is_node_up = False
if is_node_up:
server_def_link = DBSession.query(ServerDefLink).filter_by(server_id=node.id)
if server_def_link:
for each_link in server_def_link:
defn = DBSession.query(StorageDef).filter_by(id=each_link.def_id).first()
if defn:
if defn.type == constants.NFS or defn.type == constants.OCFS or defn.type == constants.CIFS or defn.type == constants.GFS:
scan_result = self.test_storage_def(auth, node, group, eachsite, defn)
self.update_size(defn, scan_result)
def update_size(self, defn, scan_result):
LOGGER.info('Updating sizes...')
if not scan_result:
LOGGER.info('Scan result is empty. Not updating sizes.')
return None
success = scan_result.get('success')
if not success:
LOGGER.info('Scan is failed. Not updating sizes.')
return None
objDetailsList = scan_result['DETAILS']
if not objDetailsList:
LOGGER.error('DETAILS object is not found in scan result. Can not update size in storage_definitions table.')
return None
for each_disk in objDetailsList:
unique_path = each_disk.get('uuid')
if unique_path:
used_size = each_disk.get('USED')
if not used_size:
used_size = 0
if float(used_size) < 0:
used_size = 0
storage_disk = DBSession.query(StorageDisks).filter_by(storage_id=defn.id, unique_path=to_unicode(unique_path)).first()
if storage_disk:
storage_disk.disk_size = used_size
LOGGER.info('Storage disk is updated')
transaction.commit()
def RemoveScanResult(self):
result = self.storage_manager.RemoveScanResult()
return result
def SaveScanResult(self, storage_id, site_id):
scan_result = None
result = self.storage_manager.SaveScanResult(storage_id, self.manager, scan_result, site_id)
return result
def add_storage_disk_manually(self, add_manually, auth, group_id, storage_id, actual_size, allocated_size, unique_path, current_portal, target, state, lun, storage_allocated):
try:
storage_disk_id = self.storage_manager.add_storage_disk(storage_id, actual_size, allocated_size, unique_path, current_portal, target, state, lun, storage_allocated, self.manager, add_manually)
vm_disk_list = self.manager.get_vm_disks_from_pool(auth, group_id)
self.manager.matching_disk_on_discover_storage(vm_disk_list, storage_disk_id)
return "{success:true, msg:''}"
except Exception as ex:
error_msg = to_str(ex).replace("'", '')
LOGGER.error(error_msg)
return "{success:false, msg:'" + error_msg + "'}"
def remove_storage_disk_cli(self, storage_disk_name):
storagedisk = DBSession.query(StorageDisks).filter(StorageDisks.unique_path == storage_disk_name).first()
if storagedisk:
storage_disk_id = storagedisk.id
result = self.remove_storage_disk_manually(storage_disk_id)
if result == "{success:true, msg:''}":
return dict(success=True, msg='The storage disk ' + storage_disk_name + ' removed successfully\n')
return dict(success=False, msg=result)
return dict(success=False, msg='The storage disk ' + storage_disk_name + ' does not exists')
def remove_storage_disk_manually(self, storage_disk_id):
try:
self.manager.remove_storage_disk_links(storage_disk_id)
self.storage_manager.remove_storage_disk_manually(storage_disk_id)
return "{success:true, msg:''}"
except Exception as ex:
error_msg = to_str(ex).replace("'", '')
LOGGER.error(error_msg)
return "{success:false, msg:'" + error_msg + "'}"
def mark_storage_disk(self, storage_disk_id, used):
try:
self.storage_manager.mark_storage_disk(storage_disk_id, used)
return "{success:true, msg:''}"
except Exception as ex:
error_msg = to_str(ex).replace("'", '')
LOGGER.error(error_msg)
return "{success:false, msg:'" + error_msg + "'}"
def mark_storage_disk_cli(self, storage, used):
storagedisk = DBSession.query(StorageDisks).filter(StorageDisks.unique_path == storage).first()
if storagedisk:
storage_disk_id = storagedisk.id
result = self.mark_storage_disk(storage_disk_id, used)
if result == "{success:true, msg:''}":
return dict(success=True, msg='The storage disk ' + storage + ' allocated successfully')
return dict(success=False, msg=result)
return dict(success=False, msg='The storage disk ' + storage + ' does not exists')
def create_disk(self, context, managed_node=None):
self.storage_manager.execute_create_disk_script(context, managed_node)
def remove_disk(self, context, managed_node=None):
self.storage_manager.execute_remove_disk_script(context, managed_node)
