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 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_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 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 get_target_images(self, auth, nodeId, imageGroupId):
try:
manager = Basic.getGridManager()
managed_node = manager.getNode(auth, nodeId)
if managed_node is None:
raise Exception('Cannot find the Managed Node.')
result = []
image_groups = {}
if imageGroupId is not None:
image_group = self.image_store.get_image_group(auth, imageGroupId)
image_groups = {image_group.get_id():image_group}
else:
image_groups = self.image_store.get_image_groups(auth)
for image_group in image_groups.itervalues():
images = self.image_store.get_group_images(auth, image_group.id)
for image in images.itervalues():
if managed_node.is_image_compatible(image) and not image.is_template:
result.append(dict(name=image.get_name(), id=image.get_id(), group_id=image_group.get_id()))
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "'}")
return dict(success='true', images=result)
def get_target_image_groups(self, auth, nodeId):
try:
manager = Basic.getGridManager()
managed_node = manager.getNode(auth, nodeId)
result = []
if managed_node is None:
raise Exception('Cannot find the Managed Node.')
result = []
mnode_ent = auth.get_entity(managed_node.id)
dc_ent = mnode_ent.parents[0].parents[0]
image_groups = self.image_store.get_image_groups(auth,dc_ent.entity_id)
for image_group in image_groups.itervalues():
count = 0
images = self.get_group_images(auth, image_group.id)
for image in images.itervalues():
if managed_node.is_image_compatible(image):
count = count + 1
break
if count > 0:
result.append(dict(name=image_group.get_name(), id=image_group.get_id()))
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "'}")
return dict(success='true', image_groups=result)
def exec_cmd(self, cmd, exec_path=None, timeout=-1, params=None, cd=False, env=None, pid_file=None):
evn_str = ''
if env is not None:
for env_var in env.keys():
evn_str += 'export ' + env_var + '=' + env.get(env_var) + ';'
if self.use_bash_timeout:
bash_script = os.path.join(self.local_bash_dir, 'bash_timeout.sh')
if self.isRemote:
bash_script = os.path.join(self.bash_dir, 'bash_timeout.sh')
bash_cmd = ''
if timeout == -1:
bash_cmd = bash_script + ' -t ' + to_str(self.default_bash_timeout) + ' '
elif timeout is not None:
bash_cmd = bash_script + ' -t ' + to_str(timeout) + ' '
if pid_file is not None:
bash_cmd = bash_cmd + '-p ' + pid_file + ' '
cmd = bash_cmd + cmd
if timeout == -1:
timeout = None
if exec_path is not None and exec_path is not '':
exec_cmd = 'PATH=$PATH:%s; %s' % (exec_path, cmd)
if cd == True:
exec_cmd = 'cd ' + exec_path + ';' + exec_cmd
else:
exec_cmd = cmd
exec_cmd = evn_str + exec_cmd
if self.isRemote:
return self.remote_exec_cmd(exec_cmd, timeout, params)
else:
return self.local_exec_cmd(exec_cmd, timeout, params)
def send_test_email(self, desc, servername, port, useremail, password, secure):
self.sender = useremail
Record = DBSession.query(User.email_address).filter(User.user_name == 'admin').first()
self.receivers = Record.email_address
self.mail_server = servername
if port:
self.port = int(port)
self.secure_type = int(secure)
self.password = password
self.subject = 'Test Email'
self.content = "\Test message Sent on " + to_str(ct_time())
self.msg = MIMEText(self.content, self.text_subtype)
self.msg['Subject'] = 'stackone Test Email'
try:
if self.secure_type == NONSECURE:
EmailManager().send_nonsecure(servername, self.port, useremail, Record.email_address, self.msg.as_string())
else:
if self.secure_type == TLS:
EmailManager().send_tls(servername, self.port, useremail, password, Record.email_address, self.msg.as_string())
else:
EmailManager().send_ssl(servername, self.port, useremail, password, Record.email_address, self.msg.as_string())
except Exception as ex:
LOGGER.error('Error sending mails:' + to_str(ex).replace("'", ''))
raise ex
message = 'mail send to ' + Record.email_address
return message
def add_image_group(self, group_name,store_id):
try:
result = self.template_controller.add_image_group(group_name,store_id)
except Exception,ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",''))
return "{success: false,msg: '" + to_str(ex).replace("'",'') +"'}"
def save_image_script(self, auth, image_id, content):
try:
mgd_node = Basic.local_node
self.image_store.save_image_script(auth, mgd_node, image_id, content)
except Exception as ex:
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "'}")
return "{success: true,msg: 'Success'}"
def clone_image(self, image_id, image_name, group_id,group_name):
try:
result = None
result = self.template_controller.clone_image(image_id, image_name, group_id, group_name)
except Exception, ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",""))
return "{success: false,msg: '",to_str(ex).replace("'",""),"'}"
def transfer_image(self, auth, image_id, source_group_id, dest_group_id):
try:
self.image_store.transfer_image(auth, image_id, source_group_id, dest_group_id)
except Exception as ex:
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "'}")
return "{success: true,msg: 'Success'}"
def remove_image_group(self, auth, group_id):
try:
self.image_store.delete_group(auth, group_id)
except Exception as ex:
LOGGER.error(to_str(ex).replace("'", ''))
return "{success: false,msg: '" + to_str(ex).replace("'", '') + "'}"
return "{success: true,msg: 'Success'}"
def remove_csep_context(self, context):
try:
result = self.csep_service.remove_csep_context(session['auth'],context)
return {'success':True,'result':result,'msg':'','error_msg':''}
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex))
return {'success':False,'result':None,'msg':'','error_msg':to_str(ex)}
def check_image_exists(self, auth, image_name):
try:
if self.image_store.image_exists_by_name(image_name):
return "{success: true,exists:true,msg: 'Image with the same name exists.'}"
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return "{success: false,msg: '" + to_str(ex).replace("'", '') + "'}"
return "{success: true,exists:false,msg: 'Success'}"
def rename_image(self, auth, image_id, image_name, group_id):
try:
self.image_store.rename_image(auth, group_id, image_id, image_name)
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return "{success: false,msg: '" + to_str(ex).replace("'", '') + "'}"
return "{success: true,msg: 'Success'}"
def restore_vm(self, node_id, file, date=None, time=None):
self.authenticate()
try:
result = to_str(self.tc.restore_vm(session['auth'], node_id, file, date, time))
except Exception as ex:
print_traceback()
return dict(success=False, msg=to_str(ex))
return dict(success=True, msg='Restore Virtual Machine task submitted.', taskid=result)
def get_default_bridge(self):
try:
default_bridge = self.environ['default_bridge']
return default_bridge
except Exception as e:
LOGGER.error('Exception : ' + to_str(e) + ' on ' + self.hostname)
print 'Exception : ' + to_str(e) + ' on ' + self.hostname
traceback.print_exc()
return None
def remove_image(self, image_id, group_id):
try:
result = None
result = self.template_controller.remove_image(image_id, group_id)
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'",''))
return "{success: false,msg:'"+ to_str(ex).replace("'",'') + "'}"
return "{success: true,msg: 'Task Submitted'}"
def server_action(self, node_id, action, date=None, time=None):
self.authenticate()
try:
result = to_str(self.tc.server_action(session['auth'], node_id, action, date, time))
except Exception as ex:
print_traceback()
return dict(success=False, msg=to_str(ex))
return dict(success=True, msg='Task submitted.', taskid=result)
def save_image_desc(self, auth, image_id, content):
#LOGGER.info('+++++++++ImageService.save_image_desc+++++++++++++++')
try:
mgd_node = Basic.local_node
self.image_store.save_image_desc(auth, mgd_node, image_id, content)
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "'}")
return "{success: true,msg: 'Success'}"
def remove_image(self, auth, image_id, group_id):
try:
im = self.get_image(auth,image_id)
image_store = im.get_image_store(auth)
msg = image_store.delete_image(auth, group_id, image_id)
return msg
except Exception as ex:
print_traceback()
LOGGER.error(to_str(ex).replace("'", ''))
raise Exception("{success: false,msg: '" + to_str(ex).replace("'", '') + "'}")
def get_disk_info(self):
try:
disk_info = self.environ['disk_info']
if disk_info is None:
return []
return disk_info
except Exception as e:
LOGGER.error('Exception : ' + to_str(e) + ' on ' + self.hostname)
print 'Exception : ' + to_str(e) + ' on ' + self.hostname
traceback.print_exc()
return []
def get_bridge_info(self):
try:
bridge_info = self.environ['bridge_info']
if bridge_info is None:
return {}
return bridge_info
except Exception as e:
LOGGER.error('Exception : ' + to_str(e) + ' on ' + self.hostname)
print 'Exception : ' + to_str(e) + ' on ' + self.hostname
traceback.print_exc()
return {}
def get_vm_status(self, image_id):
result = []
vms = DBSession.query(VM).filter(VM.image_id == image_id).all()
count_run = 0
for vm in vms:
vm_state = vm.get_state_string()
if vm_state == 'Running' or vm_state == 'Blocked':
count_run += 1
result.append(dict(name='Provisioned VMs:', value=to_str(len(vms))))
result.append(dict(name='Running VMs:', value=to_str(count_run)))
return result
def get_tasks(self, node_id, node_type, display_type=None):
result = None
try:
result = self.node_service.get_tasks(session['auth'], node_id, node_type, display_type)
except Exception as ex:
LOGGER.error(to_str(ex).replace("'", ''))
return ("{success: false,msg: '", to_str(ex).replace("'", ''), "'}")
return dict(success='true', rows=result)
def get_storage_resources_info(self):
try:
storage_info = self.environ['storage_info']
if storage_info is None:
return {}
return storage_info
except Exception as e:
LOGGER.error('Exception : ' + to_str(e) + ' on ' + self.hostname)
print 'Exception : ' + to_str(e) + ' on ' + self.hostname
traceback.print_exc()
return {}
def get_virtual_networks_info(self):
try:
virt_nw_info = self.environ['virt_nw_info']
if virt_nw_info is None:
return {}
return virt_nw_info
except Exception as e:
LOGGER.error('Exception : ' + to_str(e) + ' on ' + self.hostname)
print 'Exception : ' + to_str(e) + ' on ' + self.hostname
traceback.print_exc()
return {}
def set_chain_name(self, context):
binary_name = 'stackone-nw'
if tg.config.get('fw_namespace') in constants.TRUE_CHECK:
if context:
if context.find(' ') >= 0L:
context = context.replace(' ', '_')
constants.FW_CHAIN_NAME = to_str(binary_name) + '-' + to_str(context)
else:
constants.FW_CHAIN_NAME = to_str(binary_name)
else:
constants.FW_CHAIN_NAME = to_str(binary_name)
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) + "'}"
