def get_vm_restore_task_result(self, auth, vm_id):
task_backup_info = {}
tasklist_info = []
msg = " Number of VM's backed up= 2 \n Number of VM backup suceeded = 2\n Number of VM backup failed = 0"
vmrestore_result_obj_list = DBSession.query(VMRestoreResult, VMBackupResult).join((VMBackupResult, VMRestoreResult.backup_result_id == VMBackupResult.id)).filter(VMRestoreResult.vm_id == vm_id).order_by(VMRestoreResult.start_time).all()
if vmrestore_result_obj_list:
for vm_result_obj in vmrestore_result_obj_list:
vmrestore_result_obj = vm_result_obj[0]
vmbackup_result_obj = vm_result_obj[1]
sp_bkp_conf = DBSession.query(SPBackupConfig).filter_by(id=vmrestore_result_obj.backup_id).first()
if sp_bkp_conf:
detailResult_obj_list = DBSession.query(VMRestoreDetailResult).filter_by(result_id=vmrestore_result_obj.id).order_by(VMRestoreDetailResult.details).all()
msg2 = ''
if detailResult_obj_list:
for detailResult_obj in detailResult_obj_list:
if detailResult_obj:
msg2 += detailResult_obj.details + '\n'
task_info = {}
task_info['taskid'] = vmrestore_result_obj.id
task_info['status'] = vmrestore_result_obj.status
task_info['name'] = sp_bkp_conf.name
location = ''
exec_context = vmbackup_result_obj.execution_context
location = exec_context['SERVER'] + ':' + exec_context['BACKUP_DESTINATION']
task_info['location'] = location
task_info['backup_size'] = 0
task_info['starttime'] = vmrestore_result_obj.start_time
task_info['endtime'] = vmrestore_result_obj.end_time
task_info['errmsg'] = msg2
task_info['restore'] = vmrestore_result_obj.id
tasklist_info.append(task_info)
task_backup_info['rows'] = tasklist_info
return task_backup_info
def create_vmw_server_pool(self, auth, name, actual_name, moid, vcenter_id, parent_ent=None):
msg = ''
entityType = to_unicode(constants.SERVER_POOL)
sp = None
update_name = False
sp_ent = auth.get_entity_by_entity_attributes(self.get_entity_attributes_dict(vcenter_id, moid), entityType)
if not sp_ent:
dup_ent = auth.get_entity_by_name(name, entityType=entityType)
if dup_ent:
msg += '\nERROR: Could not import Server Pool:%s. It is already exist,please choose different name' % name
return (msg, None, None)
if sp_ent:
update_name = self.can_update_managed_object_name(auth, name, actual_name, sp_ent.name)
msg += '\nServer Pool: %s already exist' % name
sp = DBSession.query(VMWServerGroup).filter(VMWServerGroup.id == sp_ent.entity_id).first()
if sp:
if update_name:
sp.name = name
if not sp:
msg += '\nCreating Server Pool: %s' % name
sp = VMWServerGroup(name)
DBSession.add(sp)
if not sp_ent:
cntx = {'external_manager_id': vcenter_id, 'external_id': moid}
sp_ent = self.add_vcenter_entity(auth, cntx, sp.name, sp.id, to_unicode(constants.SERVER_POOL), parent_ent)
else:
if not update_name:
name = None
auth.update_entity(sp_ent, name=name, parent=parent_ent)
return (msg, sp, sp_ent)
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_next_id(self, pool_tag, context):
available_id = None
interface = None
if pool_tag == constants.VLAN_ID_POOL:
LOGGER.info("Get next vlan id from pool...")
pool_id = context.get("pool_id")
nw_def_id = context.get("nw_def_id")
null_value = None
LOGGER.info("Getting CMS Lock...")
LockManager().get_lock(
constants.VLAN_ID_POOL, pool_id, constants.NEXT_VLAN_ID, constants.Table_vlan_id_pools
)
interface = VLANManager().get_interface(pool_id)
rs = (
DBSession.query(func.min(VLANID.vlan_id).label("vlan_id"))
.join((VLANIDPool, VLANIDPool.id == VLANID.vlan_id_pool_id))
.filter(VLANID.used_by == null_value)
.filter(VLANIDPool.id == pool_id)
.first()
)
is_tuple = isinstance(rs, tuple)
if is_tuple and rs[0]:
available_id = rs.vlan_id
LOGGER.info("Available vlan id is " + to_str(available_id))
context["vlan_id"] = available_id
self.mark_used(pool_tag, context)
vlan = DBSession.query(VLANIDPool).filter(VLANIDPool.id == pool_id).first()
if vlan:
vlan.used = int(vlan.used) + 1
LOGGER.info("Releasing CMS Lock...")
LockManager().release_lock()
return (available_id, interface)
def get_fw_info(self):
fw_main_data = []
LOGGER.info("Getting firewall rules info for all csep and Data Center...")
print "Getting firewall rules info for all csep and Data Center..."
sites = DBSession.query(Site)
if sites[0]:
LOGGER.info("Got the site. Site name is " + to_str(sites[0L].name))
site_id = sites[0L].id
site_name = sites[0L].name
nw_service_host = get_cms_network_service_node()
if nw_service_host:
fw = self.get_firewall(site_id)
fw.set_chain_name(site_name)
fw_data = self.dump(fw)
fw_main_data.append(fw_data)
csep_list = DBSession.query(CSEP)
for each_csep in csep_list:
LOGGER.info("Got the CSEP. CSEP name is " + to_str(each_csep.name))
nw_service_host = each_csep.get_nw_service_host()
if nw_service_host:
fw = self.get_firewall(each_csep.id)
fw.set_chain_name(each_csep.name)
fw_data = self.dump(fw)
fw_main_data.append(fw_data)
return fw_main_data
def create_vlan_network_info(self, vlan_id_pool, cidr, num_networks, network_size, vlan_start, interface):
vlan_nw_infos = self.get_vlan_network_info(cidr, num_networks, network_size, vlan_start, interface)
for info_dict in vlan_nw_infos:
vlan_nw_info_db = self.create_vlan_network_info_db(info_dict)
vlan_nw_info_db.vlan_pool_id = vlan_id_pool.id
DBSession.add(vlan_nw_info_db)
LOGGER.info("created vlan_network_info for vlan_id_pool:%s" % vlan_id_pool.name)
def delete_pool(self, pool_ids):
if not isinstance(pool_ids, list):
pool_ids = [pool_ids]
pools = DBSession.query(IPPool).filter(IPPool.id.in_(pool_ids)).all()
DBSession.query(IPS).filter(IPS.pool_id.in_(pool_ids)).delete()
for pool in pools:
DBSession.delete(pool)
def add_firewall_for_entity(self, entity_id):
LOGGER.info("Add firewall for CSEP/ Data Center...")
if entity_id:
csep = DBSession.query(CSEP).filter_by(id=entity_id).first()
if csep:
LOGGER.info("Got CSEP")
nw_service_host = csep.get_nw_service_host()
if nw_service_host:
fw = IptablesManager(csep.name)
self.fw_map[entity_id] = fw
LOGGER.info("Firewall is added to CSEP")
self.set_nw_service_host(fw, nw_service_host)
LOGGER.info("Network service host is added to firewall")
return fw
dc = DBSession.query(Site).filter_by(id=entity_id).first()
if dc:
LOGGER.info("Got DC")
nw_service_host = get_cms_network_service_node()
if nw_service_host:
fw = IptablesManager(dc.name)
self.fw_map[entity_id] = fw
LOGGER.info("Firewall is added to DC")
self.set_nw_service_host(fw, nw_service_host)
LOGGER.info("Network service host is added to firewall")
return fw
def remove_context(cls, context_id):
try:
DBSession.query(cls).filter(cls.id == context_id).delete()
except Exception as e:
LOGGER.error(e)
traceback.print_exc()
raise e
def update_avail(node, new_state, monit_state, timestamp, reason, logger, update=True, auth=None):
sv_point = transaction.savepoint()
try:
strt = p_task_timing_start(logger, "UpdateAvailability", node.id, log_level="DEBUG")
node.current_state.avail_state = new_state
node.current_state.timestamp = timestamp
node.current_state.description = reason
avh=DBSession.query(AvailHistory).filter(AvailHistory.entity_id==node.id).\
order_by(AvailHistory.timestamp.desc()).first()
if avh is not None:
avh.endtime=timestamp
time_diff=timestamp-avh.timestamp
avh.period=time_diff.days*24*60+time_diff.seconds/60
DBSession.add(avh)
#insert availability history
ah = AvailHistory(node.id, new_state, monit_state, timestamp, reason)
DBSession.add(ah)
DBSession.add(node)
if update==True:
487
ev_contents = {'state':new_state}
ev = AvailabilityEvent(node.id, ev_contents, timestamp)
DBSession.add(ev)
ent = DBSession.query(Entity).filter(Entity.entity_id==node.id).first()
from stackone.model.ManagedNode import ManagedNode
if ent.type.name == constants.MANAGED_NODE and new_state == ManagedNode.DOWN:
if node.is_maintenance():
logger.info('Node:%s is in Maintenance mode' %node.hostname)
else:
notify_node_down(ent,reason)
except Exception, e:
import traceback
traceback.print_exc()
logger.error(e)
sv_point.rollback()
def update_dc_params(self, res_id, fencing_name, fencing_id, params):
try:
params = json.loads(params).get('param_obj')
hafr = DBSession.query(HAFenceResource).filter(HAFenceResource.id == res_id).one()
hafr.name = fencing_name
params_list = []
for hp in hafr.params:
params_list.append(hp)
for i in range(len(params_list)):
hafr.params.remove(params_list[i])
for param in params:
name = param.get('attribute')
value = param.get('value')
type = param.get('type')
field = param.get('field')
field_datatype = param.get('field_datatype')
sequence = param.get('sequence')
harp = HAFenceResourceParam(name, value, type, field, field_datatype, sequence)
hafr.params.append(harp)
DBSession.add(hafr)
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "'}")
return dict(success=True)
def delete_restore_single_result(self, result_id):
try:
DBSession.query(VMRestoreResult).filter(VMRestoreResult.id == result_id).delete()
LOGGER.info('VM restore single result is deleted.')
transaction.commit()
except Exception as ex:
LOGGER.error(to_str(ex).replace("'", ''))
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
def delete_vlan_network_info(self, vlan_id_pool, vlan_ids):
if not isinstance(vlan_ids, list):
vlan_ids = [vlan_ids]
DBSession.query(VLANNetworkInfo).filter(VLANNetworkInfo.vlan_id.in_(vlan_ids)).filter(
VLANNetworkInfo.vlan_pool_id == vlan_id_pool.id
).delete()
LOGGER.info("deleted vlan_network_info for vlan_id_pool:%s" % vlan_id_pool.name)
def check_for_updates(self, send_mail=False):
update_items = []
dep = None
try:
deps = DBSession.query(Deployment).all()
if len(deps) > 0:
dep = deps[0]
edition = get_product_edition()
new_updates,max_dt = self.get_new_updates(dep.deployment_id, dep.update_checked_date, edition)
if send_mail and new_updates:
self.send_update_mails(new_updates)
else:
LOGGER.error('Deployment table is not set. Update can not proceed.')
return None
except Exception as ex:
traceback.print_exc()
LOGGER.error('Error fetching updates:' + to_str(ex))
return None
try:
dep.update_checked_date = datetime.now()
DBSession.add(dep)
except:
pass
return update_items
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 manage_public_ip(self, vm_id, public_ip_id, public_ip, csep_id, add_flag):
LOGGER.info('Calling network service...')
if vm_id:
nw_vm_rel = DBSession.query(NetworkVMRelation).filter_by(vm_id=vm_id).first()
elif public_ip:
nw_vm_rel = DBSession.query(NetworkVMRelation).filter_by(public_ip_id=public_ip_id).first()
if nw_vm_rel:
LOGGER.info('Got network VM relation')
nw_def_id = nw_vm_rel.nw_def_id
private_ip_id = nw_vm_rel.private_ip_id
nw_defn = NwManager().get_defn(nw_def_id)
public_interface = ''
if nw_defn:
bridge_name = nw_defn.bridge_info.get('name')
private_ip = ''
ip_rec = self.get_ip_by_id(private_ip_id)
if ip_rec:
private_ip = self.remove_cidr_format_from_ip(ip_rec.ip)
dom_id = None
nw_service_host = NwManager().get_nw_service_host(csep_id)
if nw_service_host:
LOGGER.info('Got network service host')
public_interface = self.get_public_interface(csep_id)
ctx = {}
ctx['public_ip'] = public_ip
ctx['private_ip'] = private_ip
ctx['public_interface'] = public_interface
ctx['bridge_name'] = bridge_name
ctx['add_flag'] = add_flag
ctx['csep_id'] = csep_id
LOGGER.info('context=' + to_str(ctx))
NwManager().manage_public_ip(nw_service_host, ctx)
def set_transient_state(self, defn, transient_state, op, site_id=None, group_id=None, node_id=None):
scope = defn.scope
if op==constants.SCOPE_LEVEL:
if scope == constants.SCOPE_S:
def_link = DBSession.query(ServerDefLink).filter_by(server_id=node_id, def_id=defn.id).first()
else:
if scope == constants.SCOPE_SP:
def_link = DBSession.query(SPDefLink).filter_by(group_id=group_id, def_id=defn.id).first()
else:
if scope == constants.SCOPE_DC:
def_link = DBSession.query(DCDefLink).filter_by(site_id=site_id, def_id=defn.id).first()
if def_link:
if transient_state:
def_link.transient_state = to_unicode(transient_state)
else:
def_link.transient_state = None
LOGGER.info('Transient state of ' + to_str(defn.name) + ' is changed to ' + to_str(transient_state) + ' at definition scope level')
if op==constants.NODE_LEVEL:
def_link = DBSession.query(ServerDefLink).filter_by(server_id=node_id, def_id=defn.id).first()
if def_link:
if transient_state:
def_link.transient_state = to_unicode(transient_state)
else:
def_link.transient_state = None
LOGGER.info('Transient state of ' + to_str(defn.name) + ' is changed to ' + to_str(transient_state) + ' at node level')
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 migrate_to_servers(self, grpid, tried_sb_nodes=[], failed_doms=[], dom_ids=[]):
msg = 'Starting Maintenance migration on Node ' + self.nodename + '. Checking for VMs.'
self.msg += '\n' + msg
LOGGER.info(msg)
node = DBSession.query(ManagedNode).filter(ManagedNode.id == self.entity_id).first()
grp = DBSession.query(ServerGroup).filter(ServerGroup.id == grpid).first()
gretry_count = grp.getAttributeValue(constants.retry_count, 3)
gwait_interval = grp.getAttributeValue(constants.wait_interval, 3)
if grp.use_standby == True:
while len(failed_doms) > 0:
msg = 'Finding standby node.'
self.msg += '\n' + msg
LOGGER.info(msg)
new_node = self.find_standby_node(self.auth, None, node, exclude_ids=tried_sb_nodes)
if new_node is None:
msg = 'All standby nodes are exhausted.'
self.msg += '\n' + msg
LOGGER.info(msg)
break
failed_doms = self.dom_fail_over(failed_doms, node, new_node, gretry_count, gwait_interval, self.FENCING)
tried_sb_nodes.append(new_node.id)
tot_failed = failed_doms
tmp_failed_doms = [d for d in failed_doms]
if len(failed_doms) > 0:
tot_failed = []
for domid in tmp_failed_doms:
self.step = self.PAUSE_IN_STANDBY
dom = DBSession.query(VM).filter(VM.id == domid).first()
domname = dom.name
msg = 'Starting initial placement for ' + domname
self.msg += '\n' + msg
LOGGER.info(msg)
new_node = self.get_allocation_candidate(self.auth,dom,node)
failed = self.dom_fail_over(domid, node, new_node, gretry_count, gwait_interval, self.PAUSE_IN_STANDBY)
if len(failed) == 1:
tot_failed.append(failed[0])
if len(tot_failed)>0:
doms = DBSession.query(VM).filter(VM.id.in_(tot_failed)).all()
domnames = [d.name for d in doms]
msg = 'Failed to migrate following VMs' + to_str(domnames)
self.msg += '\n' + msg
LOGGER.info(msg)
else:
self.status = self.SUCCESS
msg = 'Successfully migrated all VMs'
self.msg += '\n' + msg
LOGGER.info(msg)
if len(tot_failed) != 0 and len(tot_failed) < len(dom_ids):
self.status = self.PARTIAL
vm_info_tup = self.get_maint_task_context(key='migrated_vms')
vm_ids = [x[0] for x in vm_info_tup]
self.add_vm_states(vm_ids)
return True
def get_standby_nodes(self):
standby_nodes = []
try:
grp_ent = DBSession.query(Entity).filter(Entity.entity_id == self.id).first()
node_ids = [x.entity_id for x in grp_ent.children]
from stackone.model.ManagedNode import ManagedNode
standby_nodes = DBSession.query(ManagedNode).filter(ManagedNode.id.in_(node_ids)).filter(ManagedNode.standby_status == ManagedNode.STANDBY).all()
except Exception,e:
import traceback
traceback.print_exc()
def reset_maintenance_mode(self):
LOGGER.debug('In reset_maintenance_mode')
node = DBSession.query(ManagedNode).filter(ManagedNode.id == self.node.id).first()
node.maintenance = False
node.maintenance_mig_node_id = None
node.maintenance_operation = 0
node.maintenance_migrate_back = False
node.maintenance_user = None
DBSession.add(node)
transaction.commit()
def delete_ip(self, exclude_ips, pool_id, cidr=None):
if not isinstance(exclude_ips, list):
exclude_ips = [exclude_ips]
del_ips = DBSession.query(IPS).filter(~IPS.ip.in_(exclude_ips)).filter(IPS.pool_id == pool_id).all()
for ip in del_ips:
if not self.can_remove_ip(ip.id):
LOGGER.info('Can not delete reserved IP:%s' % ip.ip)
raise Exception('Can not delete reserved IP:%s' % ip.ip)
for ip in del_ips:
DBSession.delete(ip)
def add_csep_defn(self, csep_id, def_id, def_type, status, oos_count):
row = DBSession.query(CSEPDefLink).filter_by(csep_id=csep_id, def_id=def_id).first()
if not row:
CPDL = CSEPDefLink()
CPDL.csep_id = csep_id
CPDL.def_type = def_type
CPDL.def_id = def_id
CPDL.status = to_unicode(status)
CPDL.oos_count = oos_count
CPDL.dt_time = datetime.now()
DBSession.add(CPDL)
def update_execution_context(self):
tid = TaskUtil.get_task_context()
WRK_LOGGER.debug('in update_execution_context Parent task : ' + str(tid) + ' : child tasks :' + str(self.worker_ids))
task = Task.get_task(tid)
if task is not None:
self.execution_context['start_time'] = self.start_time
self.execution_context['worker_ids'] = self.worker_ids
task.context['execution_context'] = self.execution_context
DBSession.add(task)
WRK_LOGGER.debug('in update_execution_context updated Parent task : ' + str(tid))
def update_restore_status(self, rec):
sStatus = 'Failed'
details = 'Restore failed : CMS restarted.'
rec.status = sStatus
msg = rec.result
if msg:
rec.result = msg + '. ' + details
rec.result = details
self.add_restore_detail_result(rec.id, None, sStatus, details, cms_start=True)
DBSession.add(rec)
transaction.commit()
def add_entity_attribute(cls, ent_obj, key, value, entity_id=None):
try:
if entity_id:
ent_obj = Entity.get_entity(entity_id)
ent_atr = cls(key, value)
ent_obj.attributes.append(ent_atr)
DBSession.add(ent_atr)
except Exception as ex:
traceback.print_exc()
LOGGER.error(to_str(ex))
raise ex
def add_node_defn(self, node_id, def_id, def_type, status, details):
row = DBSession.query(ServerDefLink).filter_by(server_id=node_id, def_id=def_id).first()
if not row:
node_defn = ServerDefLink()
node_defn.server_id = to_unicode(node_id)
node_defn.def_type = to_unicode(def_type)
node_defn.def_id = def_id
node_defn.status = to_unicode(status)
node_defn.details = to_unicode(details)
node_defn.dt_time = datetime.now()
DBSession.add(node_defn)
def add_group_defn(self, group_id, def_id, def_type, status, oos_count):
row = DBSession.query(SPDefLink).filter_by(group_id=group_id, def_id=def_id).first()
if not row:
SPDL = SPDefLink()
SPDL.group_id = group_id
SPDL.def_type = def_type
SPDL.def_id = def_id
SPDL.status = status
SPDL.oos_count = oos_count
SPDL.dt_time = datetime.now()
DBSession.add(SPDL)
def add_site_defn(self, site_id, def_id, def_type, status, oos_count):
row = DBSession.query(DCDefLink).filter_by(site_id=site_id, def_id=def_id).first()
if not row:
DCDL = DCDefLink()
DCDL.site_id = site_id
DCDL.def_type = def_type
DCDL.def_id = def_id
DCDL.status = to_unicode(status)
DCDL.oos_count = oos_count
DCDL.dt_time = datetime.now()
DBSession.add(DCDL)
