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 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 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 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 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 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 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 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)
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_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_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_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 add_vCenter(self, auth, host, port, ssl, username, password):
try:
vcenter = DBSession.query(VCenter).filter(VCenter.host == host).first()
if vcenter:
raise Exception('vCenter Host already existing')
else:
vC = VCenter(host, port, ssl, username, password)
DBSession.add(vC)
return vC.id
except Exception as e:
traceback.print_exc()
raise e
def add_vm_restore_result(self, backup_id, vm_id, start_time, end_time, status, result, bkp_result_id=None):
bkp_result = VMRestoreResult()
bkp_result.id = getHexID()
bkp_result.backup_id = backup_id
bkp_result.vm_id = vm_id
bkp_result.start_time = start_time
bkp_result.end_time = end_time
bkp_result.status = status
bkp_result.result = result
bkp_result.backup_result_id = bkp_result_id
DBSession.add(bkp_result)
transaction.commit()
return bkp_result.id
def save_email_setup_details(self, desc, servername, port, useremail, password, secure):
SiteRecord = DBSession.query(Site).filter(Site.name == 'Data Center').first()
if SiteRecord:
site_id = SiteRecord.id
EmailRecord = DBSession.query(EmailSetup).filter(EmailSetup.site_id == site_id).filter(EmailSetup.mail_server == servername).first()
if EmailRecord:
return dict(success=True, msg='Duplicaate Record found in list')
else:
email_setup_obj = EmailSetup(servername, desc, port, secure, site_id, useremail, password)
DBSession.add(email_setup_obj)
emailsetupid = email_setup_obj.getEmailSetupId()
EmailManager().add_entity(to_unicode(servername), emailsetupid, to_unicode(constants.EMAIL), None)
return dict(success=True, msg='New Record Added Sucessfully')
def add_defn(self, defn, site, group, node, auth, defType, op, action_op, def_manager, grid_manager, op_level, sp_ids=None, scan_result=None, csep_id=None):
scope = op_level
if scope == constants.SCOPE_S:
entityId = node.id
elif scope == constants.SCOPE_SP:
entityId = group.id
elif scope == constants.SCOPE_DC:
entityId = site.id
elif scope == constants.SCOPE_CP:
entityId = csep_id
ent = auth.get_entity(entityId)
if not auth.has_privilege(action_op, ent):
raise Exception(constants.NO_PRIVILEGE)
if scope == constants.SCOPE_SP:
if not PrivilegeOps.check_child_privileges(auth, action_op, ent):
raise Exception(constants.NO_CHILD_PRIVILEGE % ('Servers', 'Server Pool'))
DBSession.add(defn)
nw_id = defn.id
if site:
def_manager.SaveScanResult(defn.id, grid_manager, scan_result, site.id)
def_manager.RemoveScanResult(scan_result)
errs = []
details = {}
status = to_unicode(constants.OUT_OF_SYNC)
if scope == constants.SCOPE_DC:
oos_count = 0
status = to_unicode(constants.IN_SYNC)
self.add_site_defn(site.id, defn.id, defType, status, oos_count)
def_manager.manage_defn_to_groups(site, group, sp_ids, defn, defType, op, def_manager, auth, errs, grid_manager)
elif scope == constants.SCOPE_SP:
def_manager.manage_defn_to_groups(site, group, sp_ids, defn, defType, op, def_manager, auth, errs, grid_manager)
elif scope == constants.SCOPE_S:
self.add_node_defn(node.id, defn.id, defType, status, details)
update_status = True
#def_manager.add_private_ip_pool(defn)
self.sync_node_defn(auth, node, group.id, site.id, defn, defType, op, def_manager, update_status, errs)
elif scope == constants.SCOPE_CP:
oos_count = 0
status = to_unicode(constants.IN_SYNC)
self.add_csep_defn(csep_id, defn.id, defType, status, oos_count)
def_manager.manage_defn_to_groups(site, group, sp_ids, defn, defType, op, def_manager, auth, errs, grid_manager, csep_id)
details['defn_id'] = defn.id
if node:
details['node_id'] = node.id
def_manager.on_defn_creation(auth,**details)
def_manager.Recompute(defn)
if errs:
if len(errs) > 0:
LOGGER.error('Error:' + to_str(errs))
return (errs, nw_id)
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 edit_vCenter(self, auth, id, host, port, ssl, username, password):
try:
row = DBSession.query(VCenter).filter(VCenter.id == id).first()
if row == None:
raise Exception('There is no Entity exists in the database')
row.host = host
row.ssl = ssl
row.port = port
row.credential.cred_details['username'] = username
row.credential.cred_details['password'] = password
DBSession.add(row)
return None
except Exception as e:
traceback.print_exc()
raise e
return None
def add_restore_detail_result(self, result_id, phase, status, details, cms_start=False, seq=0, restore_service=None):
s_seq = seq
if details:
seq,s_seq = self.get_comment_prefix(seq)
bkp_result = VMRestoreDetailResult()
bkp_result.id = getHexID()
bkp_result.result_id = result_id
bkp_result.phase = phase
bkp_result.status = status
bkp_result.details = s_seq + '-' + details
bkp_result.dt_time = datetime.now()
DBSession.add(bkp_result)
if not cms_start:
transaction.commit()
if restore_service:
restore_service.seq = seq
return bkp_result.id
def release_address(self, entity_id, ip_id=None):
try:
LOGGER.info('Getting CMS Lock...')
LockManager().get_lock(constants.IPS, self.id, constants.RESERVE_ADDRESS_OP, constants.Table_ip_pool)
qry = DBSession.query(IPS).filter(IPS.pool_id == self.id).filter(IPS.reserved_by == entity_id)
if ip_id:
qry = qry.filter(IPS.id == ip_id)
ips_db = qry.all()
for ip_db in ips_db:
ip_db.reserved_by = None
ip_db.vm_id = None
ip_db.allocated = False
self.used = int(self.used) - 1
DBSession.add(ip_db)
finally:
LOGGER.info('Releasing CMS Lock...')
LockManager().release_lock()
return None
def disassociate_address(self, ip_id):
ip_db = None
try:
LOGGER.info('Getting CMS Lock...')
LockManager().get_lock(constants.IPS, self.id, constants.ASSOCIATE_ADDRESS_OP, constants.Table_ip_pool)
ip_db = DBSession.query(IPS).filter(IPS.pool_id == self.id).filter(IPS.id == ip_id).first()
private_networks_vm_rel = DBSession.query(NetworkVMRelation).filter(NetworkVMRelation.public_ip_id == ip_id).filter(NetworkVMRelation.vm_id == ip_db.vm_id).first()
if private_networks_vm_rel:
private_networks_vm_rel.public_ip_id = None
DBSession.add(private_networks_vm_rel)
ip_db.vm_id = None
DBSession.add(ip_db)
return ip_db
finally:
LOGGER.info('Releasing CMS Lock...')
LockManager().release_lock()
LOGGER.info('IP:%s disassociated' % ip_db.ip)
return None
def associate_address(self, ip_id, vm_id):
try:
LOGGER.info('Getting CMS Lock...')
LockManager().get_lock(constants.IPS, self.id, constants.ASSOCIATE_ADDRESS_OP, constants.Table_ip_pool)
ip_db = DBSession.query(IPS).filter(IPS.pool_id == self.id).filter(IPS.id == ip_id).filter(IPS.allocated == True).first()
ip_db.vm_id = vm_id
vm = DBSession.query(VM).filter(VM.id == vm_id).first()
if vm:
private_networks_vm_rel = vm.network_vm_relations
if len(private_networks_vm_rel):
private_networks_vm_rel[0].public_ip_id = ip_id
DBSession.add(private_networks_vm_rel[0])
DBSession.add(ip_db)
return ip_db
finally:
LOGGER.info('Releasing CMS Lock...')
LockManager().release_lock()
LOGGER.info('IP:%s attached to VM_Id:%s' % (ip_db.ip, vm_id))
def reserve_address(self, entity_id):
try:
LOGGER.info('Getting CMS Lock...')
LockManager().get_lock(constants.IPS, self.id, constants.RESERVE_ADDRESS_OP, constants.Table_ip_pool)
ip_db = DBSession.query(IPS).filter(IPS.pool_id == self.id).filter(or_(IPS.reserved_by == None, IPS.reserved_by == '')).filter(IPS.allocated == False).first()
if not ip_db:
LOGGER.error('All IPs are Reserved')
raise Exception('All IPs are Reserved')
else:
ip_db.reserved_by = entity_id
ip_db.allocated = True
used = 0
if self.used != None:
used = int(self.used)
self.used = used + 1
DBSession.add(ip_db)
return ip_db
finally:
LOGGER.info('Releasing CMS Lock...')
LockManager().release_lock()
return None
def app_new_ip(self, addresses, cidr=None):
if not isinstance(addresses, list):
addresses = [addresses]
ips = [ip_db.ip for ip_db in self.ips]
addresses = [address for address in addresses if address not in ips]
self.iplist = addresses
self._validate_network()
for address in addresses:
ip_db = self.get_ip(address)
if not ip_db:
ips_obj = IPS()
ips_obj.pool_id = self.id
ips_obj.ip = address
self.ips.append(ips_obj)
LOGGER.info('Added IP:%s to Pool:%s' % (address, self.name))
continue
ip_db.ip = address
DBSession.add(ip_db)
LOGGER.info('Updated IP:%s in the Pool:%s' % (address, self.name))
def save_fencing_details_fordwm(self, node_id, fence_det):
#from stackone.model.LicenseManager import check_platform_expire_date
try:
managed_node = DBSession.query(ManagedNode).filter(ManagedNode.id == node_id).first()
ret,msg = check_platform_expire_date(managed_node.get_platform())
if ret == False:
raise Exception(msg)
fence_det = json.loads(fence_det)
fence_details = fence_det.get('fence_details')
entity_id = node_id
fence_details = eval(fence_details)
hare_det = DBSession.query(HAEntityResource).filter(HAEntityResource.entity_id == entity_id).all()
resids = [hare.id for hare in hare_det]
for fen in fence_details:
resource_id = fen.get('id')
order = 1
haer = HAEntityResource(entity_id, resource_id, order)
param_list = fen.get('params')
for param in param_list:
name = param.get('attribute')
value = param.get('value')
type1 = param.get('type')
field = param.get('field')
field_datatype = param.get('field_datatype')
sequence = param.get('sequence')
is_environ = eval(param.get('is_environ'))
haerp = HAEntityResourceParam(name, value, type1, field, field_datatype, sequence, is_environ)
haer.params.append(haerp)
DBSession.add(haer)
DBSession.query(HAEntityResource).filter(HAEntityResource.id.in_(resids)).delete()
DBSession.query(HAEntityResourceParam).filter(HAEntityResourceParam.entity_resource_id.in_(resids)).delete()
except Exception as ex:
print_traceback()
return dict(success=False, msg=to_str(ex))
return dict(success=True, result='success')
def set_server_maintenance(self, info):
try:
msg = '\n----- Maintenance setting of Node: %s ------' %self.node.hostname
LOGGER.debug('In set_server_maintenance: \ninfo\n%s' %info)
if not info['maintenance']:
msg += '\n Node:%s leaving Maintenance mode' %self.node.hostname
else:
self.node.maintenance = info['maintenance']
if info['do_nothing']:
msg += '\n Do not shutdown or migrate Virtual Machines'
self.node.maintenance_operation = Maintenance.DO_NOTHING
if info['shutdown_vms']:
msg += '\n Shutdown all vms'
self.node.maintenance_operation = Maintenance.SHUTDOWN_ALL_VMS
elif info['migrate_to_other_server']:
msg += '\n Migrate vms to other servers in the server pool'
self.node.maintenance_operation = Maintenance.MIGRATE_VMS_TO_SERVERS
if info['migrate_vms_back_from_servers']:
msg += '\n Migrate vms back from servers, when server come out of maintenance mode'
self.node.maintenance_migrate_back = True
else:
self.node.maintenance_migrate_back = False
elif info['migrate_to_specific_server']:
msg += '\n Migrate vms to a specific server in the server pool'
self.node.maintenance_operation = Maintenance.MIGRATE_VMS_TO_SERVER
if info['migrate_vms_back_from_specific_server']:
msg += '\n Migrate vms back from servers, when server come out of maintenance mode'
self.node.maintenance_migrate_back = True
else:
self.node.maintenance_migrate_back = False
self.node.maintenance_mig_node_id = info.get('server')
self.node.maintenance_user = self.auth.user_name
LOGGER.debug(msg)
DBSession.add(self.node)
transaction.commit()
except Exception,ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",''))
return {'success':False,'msg':to_str(ex).replace("'",'')}
def save_dc_params(self, fencing_name, fencing_id, params):
try:
params = json.loads(params).get('param_obj')
har = HAFenceResource(fencing_name, fencing_id)
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)
har.params.append(harp)
DBSession.add(har)
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 create_vmw_datacenter(self, auth, name, actual_name, moid, vcenter_id, parent_ent=None):
msg = ''
entityType = to_unicode(constants.DATA_CENTER)
dc = None
update_name = False
dc_ent = auth.get_entity_by_entity_attributes(self.get_entity_attributes_dict(vcenter_id, moid), entityType)
if not dc_ent:
dup_ent = auth.get_entity_by_name(name, entityType=entityType)
if dup_ent:
msg += '\nERROR: Could not import Datacenter:%s. It is already exist,please choose different name' % name
return (msg, None, None)
if dc_ent:
update_name = self.can_update_managed_object_name(auth, name, actual_name, dc_ent.name)
msg += '\nDatacenter: %s already exist' % name
dc = DBSession.query(VMWDatacenter).filter(VMWDatacenter.id == dc_ent.entity_id).first()
if dc:
if update_name:
dc.name = name
if not dc:
msg += '\nCreating Datacenter: %s' % name
dc = VMWDatacenter(name)
DBSession.add(dc)
if not dc_ent:
dc_ent = Entity()
dc_ent.name = dc.name
dc_ent.entity_id = dc.id
dc_ent.type_id = 1
ent_cntx_dict = self.get_entity_context_dict(external_manager_id=vcenter_id, external_id=moid)
dc_ent.context_id = auth.add_context(ent_cntx_dict)
DBSession.add(dc_ent)
admin_role = auth.get_admin_role()
auth.make_rep_entry(admin_role, dc_ent)
ent_attr_dict = self.get_entity_attributes_dict(external_manager_id=vcenter_id, external_id=moid)
self.add_entity_attributes(dc_ent, ent_attr_dict)
else:
if not update_name:
name = None
auth.update_entity(dc_ent, name=name)
return (msg, dc, dc_ent)
def add_vlan_id_pool(self, auth, site_id, name, desc, range, interface, sp_ids, cidr, num_hosts):
LOGGER.info("Adding VLAN ID Pool..")
vlan_id_pool = VLANIDPool()
vlan_id_pool_id = getHexID()
vlan_id_pool.id = vlan_id_pool_id
vlan_id_pool.name = name
vlan_id_pool.description = desc
vlan_id_pool.range = range
vlan_id_pool.interface = interface
vlan_id_pool.cidr = cidr
vlan_id_pool.num_hosts = num_hosts
rnge = range.split("-")
diff = int(rnge[1]) - int(rnge[0])
vlan_id_pool.total = diff
network_size = num_hosts
num_networks = diff + 1
vlan_start = rnge[0]
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_id_pool.vlan_nws_infos.append(vlan_nw_info_db)
LOGGER.info("VLAN Network info added.")
self.attach_vlan_id_pool(sp_ids, vlan_id_pool)
nums = range.split("-")
first_num = nums[0]
last_num = nums[1]
i = first_num
while int(i) <= int(last_num):
vlan_id = VLANID()
vlan_id.id = getHexID()
vlan_id.vlan_id = int(i)
vlan_id.used_by = None
vlan_id_pool.vlan_ids.append(vlan_id)
i = int(i) + 1
LOGGER.info("VLAN IDs are added")
DBSession.add(vlan_id_pool)
transaction.commit()
LOGGER.info("VLAN ID Pool is added.")
def remove_vm(self, dom_id, node_id, date=None, time=None, force=False, force_cli=False):
self.authenticate()
status = {}
try:
if force_cli != True:
status = self.node_service.get_node_status(session['auth'],node_id=node_id,dom_id=dom_id)
if status and status['part_of_vdc'] == True:
raise Exception('This VM is part of VDC .This operation is not recommended.')
dom = DBSession().query(VM).filter(VM.id == dom_id).one()
tasks = DBSession.query(Task).filter(Task.task_id.in_([dom.delete_taskid])).all()
if len(tasks) > 0 and len(tasks[0].result) == 0:
self.tc.delete_task([tasks[0].task_id])
result = to_str(self.tc.vm_remove_action(session['auth'], dom_id, node_id, force, date, time))
if date is not None and time is not None:
dom.delete_taskid = result
DBSession.add(dom)
except Exception as ex:
print_traceback()
return dict(success=False, msg=to_str(ex))
return dict(success=True, msg='Remove Virtual Machine Task Submitted.', taskid=result)